<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <title>minid.interpreter</title>
  <link href="html.css" rel="stylesheet" type="text/css">
</head>
<body>
<table><tr>
<td class="linescolumn"><a id="L1" href="#L1">1</a><a id="L2" href="#L2">2</a><a id="L3" href="#L3">3</a><a id="L4" href="#L4">4</a><a id="L5" href="#L5">5</a><a id="L6" href="#L6">6</a><a id="L7" href="#L7">7</a><a id="L8" href="#L8">8</a><a id="L9" href="#L9">9</a><a id="L10" href="#L10">10</a><a id="L11" href="#L11">11</a><a id="L12" href="#L12">12</a><a id="L13" href="#L13">13</a><a id="L14" href="#L14">14</a><a id="L15" href="#L15">15</a><a id="L16" href="#L16">16</a><a id="L17" href="#L17">17</a><a id="L18" href="#L18">18</a><a id="L19" href="#L19">19</a><a id="L20" href="#L20">20</a><a id="L21" href="#L21">21</a><a id="L22" href="#L22">22</a><a id="L23" href="#L23">23</a><a id="L24" href="#L24">24</a><a id="L25" href="#L25">25</a><a id="L26" href="#L26">26</a><a id="L27" href="#L27">27</a><a id="L28" href="#L28">28</a><a id="L29" href="#L29">29</a><a id="L30" href="#L30">30</a><a id="L31" href="#L31">31</a><a id="L32" href="#L32">32</a><a id="L33" href="#L33">33</a><a id="L34" href="#L34">34</a><a id="L35" href="#L35">35</a><a id="L36" href="#L36">36</a><a id="L37" href="#L37">37</a><a id="L38" href="#L38">38</a><a id="L39" href="#L39">39</a><a id="L40" href="#L40">40</a><a id="L41" href="#L41">41</a><a id="L42" href="#L42">42</a><a id="L43" href="#L43">43</a><a id="L44" href="#L44">44</a><a id="L45" href="#L45">45</a><a id="L46" href="#L46">46</a><a id="L47" href="#L47">47</a><a id="L48" href="#L48">48</a><a id="L49" href="#L49">49</a><a id="L50" href="#L50">50</a><a id="L51" href="#L51">51</a><a id="L52" href="#L52">52</a><a id="L53" href="#L53">53</a><a id="L54" href="#L54">54</a><a id="L55" href="#L55">55</a><a id="L56" href="#L56">56</a><a id="L57" href="#L57">57</a><a id="L58" href="#L58">58</a><a id="L59" href="#L59">59</a><a id="L60" href="#L60">60</a><a id="L61" href="#L61">61</a><a id="L62" href="#L62">62</a><a id="L63" href="#L63">63</a><a id="L64" href="#L64">64</a><a id="L65" href="#L65">65</a><a id="L66" href="#L66">66</a><a id="L67" href="#L67">67</a><a id="L68" href="#L68">68</a><a id="L69" href="#L69">69</a><a id="L70" href="#L70">70</a><a id="L71" href="#L71">71</a><a id="L72" href="#L72">72</a><a id="L73" href="#L73">73</a><a id="L74" href="#L74">74</a><a id="L75" href="#L75">75</a><a id="L76" href="#L76">76</a><a id="L77" href="#L77">77</a><a id="L78" href="#L78">78</a><a id="L79" href="#L79">79</a><a id="L80" href="#L80">80</a><a id="L81" href="#L81">81</a><a id="L82" href="#L82">82</a><a id="L83" href="#L83">83</a><a id="L84" href="#L84">84</a><a id="L85" href="#L85">85</a><a id="L86" href="#L86">86</a><a id="L87" href="#L87">87</a><a id="L88" href="#L88">88</a><a id="L89" href="#L89">89</a><a id="L90" href="#L90">90</a><a id="L91" href="#L91">91</a><a id="L92" href="#L92">92</a><a id="L93" href="#L93">93</a><a id="L94" href="#L94">94</a><a id="L95" href="#L95">95</a><a id="L96" href="#L96">96</a><a id="L97" href="#L97">97</a><a id="L98" href="#L98">98</a><a id="L99" href="#L99">99</a><a id="L100" href="#L100">100</a><a id="L101" href="#L101">101</a><a id="L102" href="#L102">102</a><a id="L103" href="#L103">103</a><a id="L104" href="#L104">104</a><a id="L105" href="#L105">105</a><a id="L106" href="#L106">106</a><a id="L107" href="#L107">107</a><a id="L108" href="#L108">108</a><a id="L109" href="#L109">109</a><a id="L110" href="#L110">110</a><a id="L111" href="#L111">111</a><a id="L112" href="#L112">112</a><a id="L113" href="#L113">113</a><a id="L114" href="#L114">114</a><a id="L115" href="#L115">115</a><a id="L116" href="#L116">116</a><a id="L117" href="#L117">117</a><a id="L118" href="#L118">118</a><a id="L119" href="#L119">119</a><a id="L120" href="#L120">120</a><a id="L121" href="#L121">121</a><a id="L122" href="#L122">122</a><a id="L123" href="#L123">123</a><a id="L124" href="#L124">124</a><a id="L125" href="#L125">125</a><a id="L126" href="#L126">126</a><a id="L127" href="#L127">127</a><a id="L128" href="#L128">128</a><a id="L129" href="#L129">129</a><a id="L130" href="#L130">130</a><a id="L131" href="#L131">131</a><a id="L132" href="#L132">132</a><a id="L133" href="#L133">133</a><a id="L134" href="#L134">134</a><a id="L135" href="#L135">135</a><a id="L136" href="#L136">136</a><a id="L137" href="#L137">137</a><a id="L138" href="#L138">138</a><a id="L139" href="#L139">139</a><a id="L140" href="#L140">140</a><a id="L141" href="#L141">141</a><a id="L142" href="#L142">142</a><a id="L143" href="#L143">143</a><a id="L144" href="#L144">144</a><a id="L145" href="#L145">145</a><a id="L146" href="#L146">146</a><a id="L147" href="#L147">147</a><a id="L148" href="#L148">148</a><a id="L149" href="#L149">149</a><a id="L150" href="#L150">150</a><a id="L151" href="#L151">151</a><a id="L152" href="#L152">152</a><a id="L153" href="#L153">153</a><a id="L154" href="#L154">154</a><a id="L155" href="#L155">155</a><a id="L156" href="#L156">156</a><a id="L157" href="#L157">157</a><a id="L158" href="#L158">158</a><a id="L159" href="#L159">159</a><a id="L160" href="#L160">160</a><a id="L161" href="#L161">161</a><a id="L162" href="#L162">162</a><a id="L163" href="#L163">163</a><a id="L164" href="#L164">164</a><a id="L165" href="#L165">165</a><a id="L166" href="#L166">166</a><a id="L167" href="#L167">167</a><a id="L168" href="#L168">168</a><a id="L169" href="#L169">169</a><a id="L170" href="#L170">170</a><a id="L171" href="#L171">171</a><a id="L172" href="#L172">172</a><a id="L173" href="#L173">173</a><a id="L174" href="#L174">174</a><a id="L175" href="#L175">175</a><a id="L176" href="#L176">176</a><a id="L177" href="#L177">177</a><a id="L178" href="#L178">178</a><a id="L179" href="#L179">179</a><a id="L180" href="#L180">180</a><a id="L181" href="#L181">181</a><a id="L182" href="#L182">182</a><a id="L183" href="#L183">183</a><a id="L184" href="#L184">184</a><a id="L185" href="#L185">185</a><a id="L186" href="#L186">186</a><a id="L187" href="#L187">187</a><a id="L188" href="#L188">188</a><a id="L189" href="#L189">189</a><a id="L190" href="#L190">190</a><a id="L191" href="#L191">191</a><a id="L192" href="#L192">192</a><a id="L193" href="#L193">193</a><a id="L194" href="#L194">194</a><a id="L195" href="#L195">195</a><a id="L196" href="#L196">196</a><a id="L197" href="#L197">197</a><a id="L198" href="#L198">198</a><a id="L199" href="#L199">199</a><a id="L200" href="#L200">200</a><a id="L201" href="#L201">201</a><a id="L202" href="#L202">202</a><a id="L203" href="#L203">203</a><a id="L204" href="#L204">204</a><a id="L205" href="#L205">205</a><a id="L206" href="#L206">206</a><a id="L207" href="#L207">207</a><a id="L208" href="#L208">208</a><a id="L209" href="#L209">209</a><a id="L210" href="#L210">210</a><a id="L211" href="#L211">211</a><a id="L212" href="#L212">212</a><a id="L213" href="#L213">213</a><a id="L214" href="#L214">214</a><a id="L215" href="#L215">215</a><a id="L216" href="#L216">216</a><a id="L217" href="#L217">217</a><a id="L218" href="#L218">218</a><a id="L219" href="#L219">219</a><a id="L220" href="#L220">220</a><a id="L221" href="#L221">221</a><a id="L222" href="#L222">222</a><a id="L223" href="#L223">223</a><a id="L224" href="#L224">224</a><a id="L225" href="#L225">225</a><a id="L226" href="#L226">226</a><a id="L227" href="#L227">227</a><a id="L228" href="#L228">228</a><a id="L229" href="#L229">229</a><a id="L230" href="#L230">230</a><a id="L231" href="#L231">231</a><a id="L232" href="#L232">232</a><a id="L233" href="#L233">233</a><a id="L234" href="#L234">234</a><a id="L235" href="#L235">235</a><a id="L236" href="#L236">236</a><a id="L237" href="#L237">237</a><a id="L238" href="#L238">238</a><a id="L239" href="#L239">239</a><a id="L240" href="#L240">240</a><a id="L241" href="#L241">241</a><a id="L242" href="#L242">242</a><a id="L243" href="#L243">243</a><a id="L244" href="#L244">244</a><a id="L245" href="#L245">245</a><a id="L246" href="#L246">246</a><a id="L247" href="#L247">247</a><a id="L248" href="#L248">248</a><a id="L249" href="#L249">249</a><a id="L250" href="#L250">250</a><a id="L251" href="#L251">251</a><a id="L252" href="#L252">252</a><a id="L253" href="#L253">253</a><a id="L254" href="#L254">254</a><a id="L255" href="#L255">255</a><a id="L256" href="#L256">256</a><a id="L257" href="#L257">257</a><a id="L258" href="#L258">258</a><a id="L259" href="#L259">259</a><a id="L260" href="#L260">260</a><a id="L261" href="#L261">261</a><a id="L262" href="#L262">262</a><a id="L263" href="#L263">263</a><a id="L264" href="#L264">264</a><a id="L265" href="#L265">265</a><a id="L266" href="#L266">266</a><a id="L267" href="#L267">267</a><a id="L268" href="#L268">268</a><a id="L269" href="#L269">269</a><a id="L270" href="#L270">270</a><a id="L271" href="#L271">271</a><a id="L272" href="#L272">272</a><a id="L273" href="#L273">273</a><a id="L274" href="#L274">274</a><a id="L275" href="#L275">275</a><a id="L276" href="#L276">276</a><a id="L277" href="#L277">277</a><a id="L278" href="#L278">278</a><a id="L279" href="#L279">279</a><a id="L280" href="#L280">280</a><a id="L281" href="#L281">281</a><a id="L282" href="#L282">282</a><a id="L283" href="#L283">283</a><a id="L284" href="#L284">284</a><a id="L285" href="#L285">285</a><a id="L286" href="#L286">286</a><a id="L287" href="#L287">287</a><a id="L288" href="#L288">288</a><a id="L289" href="#L289">289</a><a id="L290" href="#L290">290</a><a id="L291" href="#L291">291</a><a id="L292" href="#L292">292</a><a id="L293" href="#L293">293</a><a id="L294" href="#L294">294</a><a id="L295" href="#L295">295</a><a id="L296" href="#L296">296</a><a id="L297" href="#L297">297</a><a id="L298" href="#L298">298</a><a id="L299" href="#L299">299</a><a id="L300" href="#L300">300</a><a id="L301" href="#L301">301</a><a id="L302" href="#L302">302</a><a id="L303" href="#L303">303</a><a id="L304" href="#L304">304</a><a id="L305" href="#L305">305</a><a id="L306" href="#L306">306</a><a id="L307" href="#L307">307</a><a id="L308" href="#L308">308</a><a id="L309" href="#L309">309</a><a id="L310" href="#L310">310</a><a id="L311" href="#L311">311</a><a id="L312" href="#L312">312</a><a id="L313" href="#L313">313</a><a id="L314" href="#L314">314</a><a id="L315" href="#L315">315</a><a id="L316" href="#L316">316</a><a id="L317" href="#L317">317</a><a id="L318" href="#L318">318</a><a id="L319" href="#L319">319</a><a id="L320" href="#L320">320</a><a id="L321" href="#L321">321</a><a id="L322" href="#L322">322</a><a id="L323" href="#L323">323</a><a id="L324" href="#L324">324</a><a id="L325" href="#L325">325</a><a id="L326" href="#L326">326</a><a id="L327" href="#L327">327</a><a id="L328" href="#L328">328</a><a id="L329" href="#L329">329</a><a id="L330" href="#L330">330</a><a id="L331" href="#L331">331</a><a id="L332" href="#L332">332</a><a id="L333" href="#L333">333</a><a id="L334" href="#L334">334</a><a id="L335" href="#L335">335</a><a id="L336" href="#L336">336</a><a id="L337" href="#L337">337</a><a id="L338" href="#L338">338</a><a id="L339" href="#L339">339</a><a id="L340" href="#L340">340</a><a id="L341" href="#L341">341</a><a id="L342" href="#L342">342</a><a id="L343" href="#L343">343</a><a id="L344" href="#L344">344</a><a id="L345" href="#L345">345</a><a id="L346" href="#L346">346</a><a id="L347" href="#L347">347</a><a id="L348" href="#L348">348</a><a id="L349" href="#L349">349</a><a id="L350" href="#L350">350</a><a id="L351" href="#L351">351</a><a id="L352" href="#L352">352</a><a id="L353" href="#L353">353</a><a id="L354" href="#L354">354</a><a id="L355" href="#L355">355</a><a id="L356" href="#L356">356</a><a id="L357" href="#L357">357</a><a id="L358" href="#L358">358</a><a id="L359" href="#L359">359</a><a id="L360" href="#L360">360</a><a id="L361" href="#L361">361</a><a id="L362" href="#L362">362</a><a id="L363" href="#L363">363</a><a id="L364" href="#L364">364</a><a id="L365" href="#L365">365</a><a id="L366" href="#L366">366</a><a id="L367" href="#L367">367</a><a id="L368" href="#L368">368</a><a id="L369" href="#L369">369</a><a id="L370" href="#L370">370</a><a id="L371" href="#L371">371</a><a id="L372" href="#L372">372</a><a id="L373" href="#L373">373</a><a id="L374" href="#L374">374</a><a id="L375" href="#L375">375</a><a id="L376" href="#L376">376</a><a id="L377" href="#L377">377</a><a id="L378" href="#L378">378</a><a id="L379" href="#L379">379</a><a id="L380" href="#L380">380</a><a id="L381" href="#L381">381</a><a id="L382" href="#L382">382</a><a id="L383" href="#L383">383</a><a id="L384" href="#L384">384</a><a id="L385" href="#L385">385</a><a id="L386" href="#L386">386</a><a id="L387" href="#L387">387</a><a id="L388" href="#L388">388</a><a id="L389" href="#L389">389</a><a id="L390" href="#L390">390</a><a id="L391" href="#L391">391</a><a id="L392" href="#L392">392</a><a id="L393" href="#L393">393</a><a id="L394" href="#L394">394</a><a id="L395" href="#L395">395</a><a id="L396" href="#L396">396</a><a id="L397" href="#L397">397</a><a id="L398" href="#L398">398</a><a id="L399" href="#L399">399</a><a id="L400" href="#L400">400</a><a id="L401" href="#L401">401</a><a id="L402" href="#L402">402</a><a id="L403" href="#L403">403</a><a id="L404" href="#L404">404</a><a id="L405" href="#L405">405</a><a id="L406" href="#L406">406</a><a id="L407" href="#L407">407</a><a id="L408" href="#L408">408</a><a id="L409" href="#L409">409</a><a id="L410" href="#L410">410</a><a id="L411" href="#L411">411</a><a id="L412" href="#L412">412</a><a id="L413" href="#L413">413</a><a id="L414" href="#L414">414</a><a id="L415" href="#L415">415</a><a id="L416" href="#L416">416</a><a id="L417" href="#L417">417</a><a id="L418" href="#L418">418</a><a id="L419" href="#L419">419</a><a id="L420" href="#L420">420</a><a id="L421" href="#L421">421</a><a id="L422" href="#L422">422</a><a id="L423" href="#L423">423</a><a id="L424" href="#L424">424</a><a id="L425" href="#L425">425</a><a id="L426" href="#L426">426</a><a id="L427" href="#L427">427</a><a id="L428" href="#L428">428</a><a id="L429" href="#L429">429</a><a id="L430" href="#L430">430</a><a id="L431" href="#L431">431</a><a id="L432" href="#L432">432</a><a id="L433" href="#L433">433</a><a id="L434" href="#L434">434</a><a id="L435" href="#L435">435</a><a id="L436" href="#L436">436</a><a id="L437" href="#L437">437</a><a id="L438" href="#L438">438</a><a id="L439" href="#L439">439</a><a id="L440" href="#L440">440</a><a id="L441" href="#L441">441</a><a id="L442" href="#L442">442</a><a id="L443" href="#L443">443</a><a id="L444" href="#L444">444</a><a id="L445" href="#L445">445</a><a id="L446" href="#L446">446</a><a id="L447" href="#L447">447</a><a id="L448" href="#L448">448</a><a id="L449" href="#L449">449</a><a id="L450" href="#L450">450</a><a id="L451" href="#L451">451</a><a id="L452" href="#L452">452</a><a id="L453" href="#L453">453</a><a id="L454" href="#L454">454</a><a id="L455" href="#L455">455</a><a id="L456" href="#L456">456</a><a id="L457" href="#L457">457</a><a id="L458" href="#L458">458</a><a id="L459" href="#L459">459</a><a id="L460" href="#L460">460</a><a id="L461" href="#L461">461</a><a id="L462" href="#L462">462</a><a id="L463" href="#L463">463</a><a id="L464" href="#L464">464</a><a id="L465" href="#L465">465</a><a id="L466" href="#L466">466</a><a id="L467" href="#L467">467</a><a id="L468" href="#L468">468</a><a id="L469" href="#L469">469</a><a id="L470" href="#L470">470</a><a id="L471" href="#L471">471</a><a id="L472" href="#L472">472</a><a id="L473" href="#L473">473</a><a id="L474" href="#L474">474</a><a id="L475" href="#L475">475</a><a id="L476" href="#L476">476</a><a id="L477" href="#L477">477</a><a id="L478" href="#L478">478</a><a id="L479" href="#L479">479</a><a id="L480" href="#L480">480</a><a id="L481" href="#L481">481</a><a id="L482" href="#L482">482</a><a id="L483" href="#L483">483</a><a id="L484" href="#L484">484</a><a id="L485" href="#L485">485</a><a id="L486" href="#L486">486</a><a id="L487" href="#L487">487</a><a id="L488" href="#L488">488</a><a id="L489" href="#L489">489</a><a id="L490" href="#L490">490</a><a id="L491" href="#L491">491</a><a id="L492" href="#L492">492</a><a id="L493" href="#L493">493</a><a id="L494" href="#L494">494</a><a id="L495" href="#L495">495</a><a id="L496" href="#L496">496</a><a id="L497" href="#L497">497</a><a id="L498" href="#L498">498</a><a id="L499" href="#L499">499</a><a id="L500" href="#L500">500</a><a id="L501" href="#L501">501</a><a id="L502" href="#L502">502</a><a id="L503" href="#L503">503</a><a id="L504" href="#L504">504</a><a id="L505" href="#L505">505</a><a id="L506" href="#L506">506</a><a id="L507" href="#L507">507</a><a id="L508" href="#L508">508</a><a id="L509" href="#L509">509</a><a id="L510" href="#L510">510</a><a id="L511" href="#L511">511</a><a id="L512" href="#L512">512</a><a id="L513" href="#L513">513</a><a id="L514" href="#L514">514</a><a id="L515" href="#L515">515</a><a id="L516" href="#L516">516</a><a id="L517" href="#L517">517</a><a id="L518" href="#L518">518</a><a id="L519" href="#L519">519</a><a id="L520" href="#L520">520</a><a id="L521" href="#L521">521</a><a id="L522" href="#L522">522</a><a id="L523" href="#L523">523</a><a id="L524" href="#L524">524</a><a id="L525" href="#L525">525</a><a id="L526" href="#L526">526</a><a id="L527" href="#L527">527</a><a id="L528" href="#L528">528</a><a id="L529" href="#L529">529</a><a id="L530" href="#L530">530</a><a id="L531" href="#L531">531</a><a id="L532" href="#L532">532</a><a id="L533" href="#L533">533</a><a id="L534" href="#L534">534</a><a id="L535" href="#L535">535</a><a id="L536" href="#L536">536</a><a id="L537" href="#L537">537</a><a id="L538" href="#L538">538</a><a id="L539" href="#L539">539</a><a id="L540" href="#L540">540</a><a id="L541" href="#L541">541</a><a id="L542" href="#L542">542</a><a id="L543" href="#L543">543</a><a id="L544" href="#L544">544</a><a id="L545" href="#L545">545</a><a id="L546" href="#L546">546</a><a id="L547" href="#L547">547</a><a id="L548" href="#L548">548</a><a id="L549" href="#L549">549</a><a id="L550" href="#L550">550</a><a id="L551" href="#L551">551</a><a id="L552" href="#L552">552</a><a id="L553" href="#L553">553</a><a id="L554" href="#L554">554</a><a id="L555" href="#L555">555</a><a id="L556" href="#L556">556</a><a id="L557" href="#L557">557</a><a id="L558" href="#L558">558</a><a id="L559" href="#L559">559</a><a id="L560" href="#L560">560</a><a id="L561" href="#L561">561</a><a id="L562" href="#L562">562</a><a id="L563" href="#L563">563</a><a id="L564" href="#L564">564</a><a id="L565" href="#L565">565</a><a id="L566" href="#L566">566</a><a id="L567" href="#L567">567</a><a id="L568" href="#L568">568</a><a id="L569" href="#L569">569</a><a id="L570" href="#L570">570</a><a id="L571" href="#L571">571</a><a id="L572" href="#L572">572</a><a id="L573" href="#L573">573</a><a id="L574" href="#L574">574</a><a id="L575" href="#L575">575</a><a id="L576" href="#L576">576</a><a id="L577" href="#L577">577</a><a id="L578" href="#L578">578</a><a id="L579" href="#L579">579</a><a id="L580" href="#L580">580</a><a id="L581" href="#L581">581</a><a id="L582" href="#L582">582</a><a id="L583" href="#L583">583</a><a id="L584" href="#L584">584</a><a id="L585" href="#L585">585</a><a id="L586" href="#L586">586</a><a id="L587" href="#L587">587</a><a id="L588" href="#L588">588</a><a id="L589" href="#L589">589</a><a id="L590" href="#L590">590</a><a id="L591" href="#L591">591</a><a id="L592" href="#L592">592</a><a id="L593" href="#L593">593</a><a id="L594" href="#L594">594</a><a id="L595" href="#L595">595</a><a id="L596" href="#L596">596</a><a id="L597" href="#L597">597</a><a id="L598" href="#L598">598</a><a id="L599" href="#L599">599</a><a id="L600" href="#L600">600</a><a id="L601" href="#L601">601</a><a id="L602" href="#L602">602</a><a id="L603" href="#L603">603</a><a id="L604" href="#L604">604</a><a id="L605" href="#L605">605</a><a id="L606" href="#L606">606</a><a id="L607" href="#L607">607</a><a id="L608" href="#L608">608</a><a id="L609" href="#L609">609</a><a id="L610" href="#L610">610</a><a id="L611" href="#L611">611</a><a id="L612" href="#L612">612</a><a id="L613" href="#L613">613</a><a id="L614" href="#L614">614</a><a id="L615" href="#L615">615</a><a id="L616" href="#L616">616</a><a id="L617" href="#L617">617</a><a id="L618" href="#L618">618</a><a id="L619" href="#L619">619</a><a id="L620" href="#L620">620</a><a id="L621" href="#L621">621</a><a id="L622" href="#L622">622</a><a id="L623" href="#L623">623</a><a id="L624" href="#L624">624</a><a id="L625" href="#L625">625</a><a id="L626" href="#L626">626</a><a id="L627" href="#L627">627</a><a id="L628" href="#L628">628</a><a id="L629" href="#L629">629</a><a id="L630" href="#L630">630</a><a id="L631" href="#L631">631</a><a id="L632" href="#L632">632</a><a id="L633" href="#L633">633</a><a id="L634" href="#L634">634</a><a id="L635" href="#L635">635</a><a id="L636" href="#L636">636</a><a id="L637" href="#L637">637</a><a id="L638" href="#L638">638</a><a id="L639" href="#L639">639</a><a id="L640" href="#L640">640</a><a id="L641" href="#L641">641</a><a id="L642" href="#L642">642</a><a id="L643" href="#L643">643</a><a id="L644" href="#L644">644</a><a id="L645" href="#L645">645</a><a id="L646" href="#L646">646</a><a id="L647" href="#L647">647</a><a id="L648" href="#L648">648</a><a id="L649" href="#L649">649</a><a id="L650" href="#L650">650</a><a id="L651" href="#L651">651</a><a id="L652" href="#L652">652</a><a id="L653" href="#L653">653</a><a id="L654" href="#L654">654</a><a id="L655" href="#L655">655</a><a id="L656" href="#L656">656</a><a id="L657" href="#L657">657</a><a id="L658" href="#L658">658</a><a id="L659" href="#L659">659</a><a id="L660" href="#L660">660</a><a id="L661" href="#L661">661</a><a id="L662" href="#L662">662</a><a id="L663" href="#L663">663</a><a id="L664" href="#L664">664</a><a id="L665" href="#L665">665</a><a id="L666" href="#L666">666</a><a id="L667" href="#L667">667</a><a id="L668" href="#L668">668</a><a id="L669" href="#L669">669</a><a id="L670" href="#L670">670</a><a id="L671" href="#L671">671</a><a id="L672" href="#L672">672</a><a id="L673" href="#L673">673</a><a id="L674" href="#L674">674</a><a id="L675" href="#L675">675</a><a id="L676" href="#L676">676</a><a id="L677" href="#L677">677</a><a id="L678" href="#L678">678</a><a id="L679" href="#L679">679</a><a id="L680" href="#L680">680</a><a id="L681" href="#L681">681</a><a id="L682" href="#L682">682</a><a id="L683" href="#L683">683</a><a id="L684" href="#L684">684</a><a id="L685" href="#L685">685</a><a id="L686" href="#L686">686</a><a id="L687" href="#L687">687</a><a id="L688" href="#L688">688</a><a id="L689" href="#L689">689</a><a id="L690" href="#L690">690</a><a id="L691" href="#L691">691</a><a id="L692" href="#L692">692</a><a id="L693" href="#L693">693</a><a id="L694" href="#L694">694</a><a id="L695" href="#L695">695</a><a id="L696" href="#L696">696</a><a id="L697" href="#L697">697</a><a id="L698" href="#L698">698</a><a id="L699" href="#L699">699</a><a id="L700" href="#L700">700</a><a id="L701" href="#L701">701</a><a id="L702" href="#L702">702</a><a id="L703" href="#L703">703</a><a id="L704" href="#L704">704</a><a id="L705" href="#L705">705</a><a id="L706" href="#L706">706</a><a id="L707" href="#L707">707</a><a id="L708" href="#L708">708</a><a id="L709" href="#L709">709</a><a id="L710" href="#L710">710</a><a id="L711" href="#L711">711</a><a id="L712" href="#L712">712</a><a id="L713" href="#L713">713</a><a id="L714" href="#L714">714</a><a id="L715" href="#L715">715</a><a id="L716" href="#L716">716</a><a id="L717" href="#L717">717</a><a id="L718" href="#L718">718</a><a id="L719" href="#L719">719</a><a id="L720" href="#L720">720</a><a id="L721" href="#L721">721</a><a id="L722" href="#L722">722</a><a id="L723" href="#L723">723</a><a id="L724" href="#L724">724</a><a id="L725" href="#L725">725</a><a id="L726" href="#L726">726</a><a id="L727" href="#L727">727</a><a id="L728" href="#L728">728</a><a id="L729" href="#L729">729</a><a id="L730" href="#L730">730</a><a id="L731" href="#L731">731</a><a id="L732" href="#L732">732</a><a id="L733" href="#L733">733</a><a id="L734" href="#L734">734</a><a id="L735" href="#L735">735</a><a id="L736" href="#L736">736</a><a id="L737" href="#L737">737</a><a id="L738" href="#L738">738</a><a id="L739" href="#L739">739</a><a id="L740" href="#L740">740</a><a id="L741" href="#L741">741</a><a id="L742" href="#L742">742</a><a id="L743" href="#L743">743</a><a id="L744" href="#L744">744</a><a id="L745" href="#L745">745</a><a id="L746" href="#L746">746</a><a id="L747" href="#L747">747</a><a id="L748" href="#L748">748</a><a id="L749" href="#L749">749</a><a id="L750" href="#L750">750</a><a id="L751" href="#L751">751</a><a id="L752" href="#L752">752</a><a id="L753" href="#L753">753</a><a id="L754" href="#L754">754</a><a id="L755" href="#L755">755</a><a id="L756" href="#L756">756</a><a id="L757" href="#L757">757</a><a id="L758" href="#L758">758</a><a id="L759" href="#L759">759</a><a id="L760" href="#L760">760</a><a id="L761" href="#L761">761</a><a id="L762" href="#L762">762</a><a id="L763" href="#L763">763</a><a id="L764" href="#L764">764</a><a id="L765" href="#L765">765</a><a id="L766" href="#L766">766</a><a id="L767" href="#L767">767</a><a id="L768" href="#L768">768</a><a id="L769" href="#L769">769</a><a id="L770" href="#L770">770</a><a id="L771" href="#L771">771</a><a id="L772" href="#L772">772</a><a id="L773" href="#L773">773</a><a id="L774" href="#L774">774</a><a id="L775" href="#L775">775</a><a id="L776" href="#L776">776</a><a id="L777" href="#L777">777</a><a id="L778" href="#L778">778</a><a id="L779" href="#L779">779</a><a id="L780" href="#L780">780</a><a id="L781" href="#L781">781</a><a id="L782" href="#L782">782</a><a id="L783" href="#L783">783</a><a id="L784" href="#L784">784</a><a id="L785" href="#L785">785</a><a id="L786" href="#L786">786</a><a id="L787" href="#L787">787</a><a id="L788" href="#L788">788</a><a id="L789" href="#L789">789</a><a id="L790" href="#L790">790</a><a id="L791" href="#L791">791</a><a id="L792" href="#L792">792</a><a id="L793" href="#L793">793</a><a id="L794" href="#L794">794</a><a id="L795" href="#L795">795</a><a id="L796" href="#L796">796</a><a id="L797" href="#L797">797</a><a id="L798" href="#L798">798</a><a id="L799" href="#L799">799</a><a id="L800" href="#L800">800</a><a id="L801" href="#L801">801</a><a id="L802" href="#L802">802</a><a id="L803" href="#L803">803</a><a id="L804" href="#L804">804</a><a id="L805" href="#L805">805</a><a id="L806" href="#L806">806</a><a id="L807" href="#L807">807</a><a id="L808" href="#L808">808</a><a id="L809" href="#L809">809</a><a id="L810" href="#L810">810</a><a id="L811" href="#L811">811</a><a id="L812" href="#L812">812</a><a id="L813" href="#L813">813</a><a id="L814" href="#L814">814</a><a id="L815" href="#L815">815</a><a id="L816" href="#L816">816</a><a id="L817" href="#L817">817</a><a id="L818" href="#L818">818</a><a id="L819" href="#L819">819</a><a id="L820" href="#L820">820</a><a id="L821" href="#L821">821</a><a id="L822" href="#L822">822</a><a id="L823" href="#L823">823</a><a id="L824" href="#L824">824</a><a id="L825" href="#L825">825</a><a id="L826" href="#L826">826</a><a id="L827" href="#L827">827</a><a id="L828" href="#L828">828</a><a id="L829" href="#L829">829</a><a id="L830" href="#L830">830</a><a id="L831" href="#L831">831</a><a id="L832" href="#L832">832</a><a id="L833" href="#L833">833</a><a id="L834" href="#L834">834</a><a id="L835" href="#L835">835</a><a id="L836" href="#L836">836</a><a id="L837" href="#L837">837</a><a id="L838" href="#L838">838</a><a id="L839" href="#L839">839</a><a id="L840" href="#L840">840</a><a id="L841" href="#L841">841</a><a id="L842" href="#L842">842</a><a id="L843" href="#L843">843</a><a id="L844" href="#L844">844</a><a id="L845" href="#L845">845</a><a id="L846" href="#L846">846</a><a id="L847" href="#L847">847</a><a id="L848" href="#L848">848</a><a id="L849" href="#L849">849</a><a id="L850" href="#L850">850</a><a id="L851" href="#L851">851</a><a id="L852" href="#L852">852</a><a id="L853" href="#L853">853</a><a id="L854" href="#L854">854</a><a id="L855" href="#L855">855</a><a id="L856" href="#L856">856</a><a id="L857" href="#L857">857</a><a id="L858" href="#L858">858</a><a id="L859" href="#L859">859</a><a id="L860" href="#L860">860</a><a id="L861" href="#L861">861</a><a id="L862" href="#L862">862</a><a id="L863" href="#L863">863</a><a id="L864" href="#L864">864</a><a id="L865" href="#L865">865</a><a id="L866" href="#L866">866</a><a id="L867" href="#L867">867</a><a id="L868" href="#L868">868</a><a id="L869" href="#L869">869</a><a id="L870" href="#L870">870</a><a id="L871" href="#L871">871</a><a id="L872" href="#L872">872</a><a id="L873" href="#L873">873</a><a id="L874" href="#L874">874</a><a id="L875" href="#L875">875</a><a id="L876" href="#L876">876</a><a id="L877" href="#L877">877</a><a id="L878" href="#L878">878</a><a id="L879" href="#L879">879</a><a id="L880" href="#L880">880</a><a id="L881" href="#L881">881</a><a id="L882" href="#L882">882</a><a id="L883" href="#L883">883</a><a id="L884" href="#L884">884</a><a id="L885" href="#L885">885</a><a id="L886" href="#L886">886</a><a id="L887" href="#L887">887</a><a id="L888" href="#L888">888</a><a id="L889" href="#L889">889</a><a id="L890" href="#L890">890</a><a id="L891" href="#L891">891</a><a id="L892" href="#L892">892</a><a id="L893" href="#L893">893</a><a id="L894" href="#L894">894</a><a id="L895" href="#L895">895</a><a id="L896" href="#L896">896</a><a id="L897" href="#L897">897</a><a id="L898" href="#L898">898</a><a id="L899" href="#L899">899</a><a id="L900" href="#L900">900</a><a id="L901" href="#L901">901</a><a id="L902" href="#L902">902</a><a id="L903" href="#L903">903</a><a id="L904" href="#L904">904</a><a id="L905" href="#L905">905</a><a id="L906" href="#L906">906</a><a id="L907" href="#L907">907</a><a id="L908" href="#L908">908</a><a id="L909" href="#L909">909</a><a id="L910" href="#L910">910</a><a id="L911" href="#L911">911</a><a id="L912" href="#L912">912</a><a id="L913" href="#L913">913</a><a id="L914" href="#L914">914</a><a id="L915" href="#L915">915</a><a id="L916" href="#L916">916</a><a id="L917" href="#L917">917</a><a id="L918" href="#L918">918</a><a id="L919" href="#L919">919</a><a id="L920" href="#L920">920</a><a id="L921" href="#L921">921</a><a id="L922" href="#L922">922</a><a id="L923" href="#L923">923</a><a id="L924" href="#L924">924</a><a id="L925" href="#L925">925</a><a id="L926" href="#L926">926</a><a id="L927" href="#L927">927</a><a id="L928" href="#L928">928</a><a id="L929" href="#L929">929</a><a id="L930" href="#L930">930</a><a id="L931" href="#L931">931</a><a id="L932" href="#L932">932</a><a id="L933" href="#L933">933</a><a id="L934" href="#L934">934</a><a id="L935" href="#L935">935</a><a id="L936" href="#L936">936</a><a id="L937" href="#L937">937</a><a id="L938" href="#L938">938</a><a id="L939" href="#L939">939</a><a id="L940" href="#L940">940</a><a id="L941" href="#L941">941</a><a id="L942" href="#L942">942</a><a id="L943" href="#L943">943</a><a id="L944" href="#L944">944</a><a id="L945" href="#L945">945</a><a id="L946" href="#L946">946</a><a id="L947" href="#L947">947</a><a id="L948" href="#L948">948</a><a id="L949" href="#L949">949</a><a id="L950" href="#L950">950</a><a id="L951" href="#L951">951</a><a id="L952" href="#L952">952</a><a id="L953" href="#L953">953</a><a id="L954" href="#L954">954</a><a id="L955" href="#L955">955</a><a id="L956" href="#L956">956</a><a id="L957" href="#L957">957</a><a id="L958" href="#L958">958</a><a id="L959" href="#L959">959</a><a id="L960" href="#L960">960</a><a id="L961" href="#L961">961</a><a id="L962" href="#L962">962</a><a id="L963" href="#L963">963</a><a id="L964" href="#L964">964</a><a id="L965" href="#L965">965</a><a id="L966" href="#L966">966</a><a id="L967" href="#L967">967</a><a id="L968" href="#L968">968</a><a id="L969" href="#L969">969</a><a id="L970" href="#L970">970</a><a id="L971" href="#L971">971</a><a id="L972" href="#L972">972</a><a id="L973" href="#L973">973</a><a id="L974" href="#L974">974</a><a id="L975" href="#L975">975</a><a id="L976" href="#L976">976</a><a id="L977" href="#L977">977</a><a id="L978" href="#L978">978</a><a id="L979" href="#L979">979</a><a id="L980" href="#L980">980</a><a id="L981" href="#L981">981</a><a id="L982" href="#L982">982</a><a id="L983" href="#L983">983</a><a id="L984" href="#L984">984</a><a id="L985" href="#L985">985</a><a id="L986" href="#L986">986</a><a id="L987" href="#L987">987</a><a id="L988" href="#L988">988</a><a id="L989" href="#L989">989</a><a id="L990" href="#L990">990</a><a id="L991" href="#L991">991</a><a id="L992" href="#L992">992</a><a id="L993" href="#L993">993</a><a id="L994" href="#L994">994</a><a id="L995" href="#L995">995</a><a id="L996" href="#L996">996</a><a id="L997" href="#L997">997</a><a id="L998" href="#L998">998</a><a id="L999" href="#L999">999</a><a id="L1000" href="#L1000">1000</a><a id="L1001" href="#L1001">1001</a><a id="L1002" href="#L1002">1002</a><a id="L1003" href="#L1003">1003</a><a id="L1004" href="#L1004">1004</a><a id="L1005" href="#L1005">1005</a><a id="L1006" href="#L1006">1006</a><a id="L1007" href="#L1007">1007</a><a id="L1008" href="#L1008">1008</a><a id="L1009" href="#L1009">1009</a><a id="L1010" href="#L1010">1010</a><a id="L1011" href="#L1011">1011</a><a id="L1012" href="#L1012">1012</a><a id="L1013" href="#L1013">1013</a><a id="L1014" href="#L1014">1014</a><a id="L1015" href="#L1015">1015</a><a id="L1016" href="#L1016">1016</a><a id="L1017" href="#L1017">1017</a><a id="L1018" href="#L1018">1018</a><a id="L1019" href="#L1019">1019</a><a id="L1020" href="#L1020">1020</a><a id="L1021" href="#L1021">1021</a><a id="L1022" href="#L1022">1022</a><a id="L1023" href="#L1023">1023</a><a id="L1024" href="#L1024">1024</a><a id="L1025" href="#L1025">1025</a><a id="L1026" href="#L1026">1026</a><a id="L1027" href="#L1027">1027</a><a id="L1028" href="#L1028">1028</a><a id="L1029" href="#L1029">1029</a><a id="L1030" href="#L1030">1030</a><a id="L1031" href="#L1031">1031</a><a id="L1032" href="#L1032">1032</a><a id="L1033" href="#L1033">1033</a><a id="L1034" href="#L1034">1034</a><a id="L1035" href="#L1035">1035</a><a id="L1036" href="#L1036">1036</a><a id="L1037" href="#L1037">1037</a><a id="L1038" href="#L1038">1038</a><a id="L1039" href="#L1039">1039</a><a id="L1040" href="#L1040">1040</a><a id="L1041" href="#L1041">1041</a><a id="L1042" href="#L1042">1042</a><a id="L1043" href="#L1043">1043</a><a id="L1044" href="#L1044">1044</a><a id="L1045" href="#L1045">1045</a><a id="L1046" href="#L1046">1046</a><a id="L1047" href="#L1047">1047</a><a id="L1048" href="#L1048">1048</a><a id="L1049" href="#L1049">1049</a><a id="L1050" href="#L1050">1050</a><a id="L1051" href="#L1051">1051</a><a id="L1052" href="#L1052">1052</a><a id="L1053" href="#L1053">1053</a><a id="L1054" href="#L1054">1054</a><a id="L1055" href="#L1055">1055</a><a id="L1056" href="#L1056">1056</a><a id="L1057" href="#L1057">1057</a><a id="L1058" href="#L1058">1058</a><a id="L1059" href="#L1059">1059</a><a id="L1060" href="#L1060">1060</a><a id="L1061" href="#L1061">1061</a><a id="L1062" href="#L1062">1062</a><a id="L1063" href="#L1063">1063</a><a id="L1064" href="#L1064">1064</a><a id="L1065" href="#L1065">1065</a><a id="L1066" href="#L1066">1066</a><a id="L1067" href="#L1067">1067</a><a id="L1068" href="#L1068">1068</a><a id="L1069" href="#L1069">1069</a><a id="L1070" href="#L1070">1070</a><a id="L1071" href="#L1071">1071</a><a id="L1072" href="#L1072">1072</a><a id="L1073" href="#L1073">1073</a><a id="L1074" href="#L1074">1074</a><a id="L1075" href="#L1075">1075</a><a id="L1076" href="#L1076">1076</a><a id="L1077" href="#L1077">1077</a><a id="L1078" href="#L1078">1078</a><a id="L1079" href="#L1079">1079</a><a id="L1080" href="#L1080">1080</a><a id="L1081" href="#L1081">1081</a><a id="L1082" href="#L1082">1082</a><a id="L1083" href="#L1083">1083</a><a id="L1084" href="#L1084">1084</a><a id="L1085" href="#L1085">1085</a><a id="L1086" href="#L1086">1086</a><a id="L1087" href="#L1087">1087</a><a id="L1088" href="#L1088">1088</a><a id="L1089" href="#L1089">1089</a><a id="L1090" href="#L1090">1090</a><a id="L1091" href="#L1091">1091</a><a id="L1092" href="#L1092">1092</a><a id="L1093" href="#L1093">1093</a><a id="L1094" href="#L1094">1094</a><a id="L1095" href="#L1095">1095</a><a id="L1096" href="#L1096">1096</a><a id="L1097" href="#L1097">1097</a><a id="L1098" href="#L1098">1098</a><a id="L1099" href="#L1099">1099</a><a id="L1100" href="#L1100">1100</a><a id="L1101" href="#L1101">1101</a><a id="L1102" href="#L1102">1102</a><a id="L1103" href="#L1103">1103</a><a id="L1104" href="#L1104">1104</a><a id="L1105" href="#L1105">1105</a><a id="L1106" href="#L1106">1106</a><a id="L1107" href="#L1107">1107</a><a id="L1108" href="#L1108">1108</a><a id="L1109" href="#L1109">1109</a><a id="L1110" href="#L1110">1110</a><a id="L1111" href="#L1111">1111</a><a id="L1112" href="#L1112">1112</a><a id="L1113" href="#L1113">1113</a><a id="L1114" href="#L1114">1114</a><a id="L1115" href="#L1115">1115</a><a id="L1116" href="#L1116">1116</a><a id="L1117" href="#L1117">1117</a><a id="L1118" href="#L1118">1118</a><a id="L1119" href="#L1119">1119</a><a id="L1120" href="#L1120">1120</a><a id="L1121" href="#L1121">1121</a><a id="L1122" href="#L1122">1122</a><a id="L1123" href="#L1123">1123</a><a id="L1124" href="#L1124">1124</a><a id="L1125" href="#L1125">1125</a><a id="L1126" href="#L1126">1126</a><a id="L1127" href="#L1127">1127</a><a id="L1128" href="#L1128">1128</a><a id="L1129" href="#L1129">1129</a><a id="L1130" href="#L1130">1130</a><a id="L1131" href="#L1131">1131</a><a id="L1132" href="#L1132">1132</a><a id="L1133" href="#L1133">1133</a><a id="L1134" href="#L1134">1134</a><a id="L1135" href="#L1135">1135</a><a id="L1136" href="#L1136">1136</a><a id="L1137" href="#L1137">1137</a><a id="L1138" href="#L1138">1138</a><a id="L1139" href="#L1139">1139</a><a id="L1140" href="#L1140">1140</a><a id="L1141" href="#L1141">1141</a><a id="L1142" href="#L1142">1142</a><a id="L1143" href="#L1143">1143</a><a id="L1144" href="#L1144">1144</a><a id="L1145" href="#L1145">1145</a><a id="L1146" href="#L1146">1146</a><a id="L1147" href="#L1147">1147</a><a id="L1148" href="#L1148">1148</a><a id="L1149" href="#L1149">1149</a><a id="L1150" href="#L1150">1150</a><a id="L1151" href="#L1151">1151</a><a id="L1152" href="#L1152">1152</a><a id="L1153" href="#L1153">1153</a><a id="L1154" href="#L1154">1154</a><a id="L1155" href="#L1155">1155</a><a id="L1156" href="#L1156">1156</a><a id="L1157" href="#L1157">1157</a><a id="L1158" href="#L1158">1158</a><a id="L1159" href="#L1159">1159</a><a id="L1160" href="#L1160">1160</a><a id="L1161" href="#L1161">1161</a><a id="L1162" href="#L1162">1162</a><a id="L1163" href="#L1163">1163</a><a id="L1164" href="#L1164">1164</a><a id="L1165" href="#L1165">1165</a><a id="L1166" href="#L1166">1166</a><a id="L1167" href="#L1167">1167</a><a id="L1168" href="#L1168">1168</a><a id="L1169" href="#L1169">1169</a><a id="L1170" href="#L1170">1170</a><a id="L1171" href="#L1171">1171</a><a id="L1172" href="#L1172">1172</a><a id="L1173" href="#L1173">1173</a><a id="L1174" href="#L1174">1174</a><a id="L1175" href="#L1175">1175</a><a id="L1176" href="#L1176">1176</a><a id="L1177" href="#L1177">1177</a><a id="L1178" href="#L1178">1178</a><a id="L1179" href="#L1179">1179</a><a id="L1180" href="#L1180">1180</a><a id="L1181" href="#L1181">1181</a><a id="L1182" href="#L1182">1182</a><a id="L1183" href="#L1183">1183</a><a id="L1184" href="#L1184">1184</a><a id="L1185" href="#L1185">1185</a><a id="L1186" href="#L1186">1186</a><a id="L1187" href="#L1187">1187</a><a id="L1188" href="#L1188">1188</a><a id="L1189" href="#L1189">1189</a><a id="L1190" href="#L1190">1190</a><a id="L1191" href="#L1191">1191</a><a id="L1192" href="#L1192">1192</a><a id="L1193" href="#L1193">1193</a><a id="L1194" href="#L1194">1194</a><a id="L1195" href="#L1195">1195</a><a id="L1196" href="#L1196">1196</a><a id="L1197" href="#L1197">1197</a><a id="L1198" href="#L1198">1198</a><a id="L1199" href="#L1199">1199</a><a id="L1200" href="#L1200">1200</a><a id="L1201" href="#L1201">1201</a><a id="L1202" href="#L1202">1202</a><a id="L1203" href="#L1203">1203</a><a id="L1204" href="#L1204">1204</a><a id="L1205" href="#L1205">1205</a><a id="L1206" href="#L1206">1206</a><a id="L1207" href="#L1207">1207</a><a id="L1208" href="#L1208">1208</a><a id="L1209" href="#L1209">1209</a><a id="L1210" href="#L1210">1210</a><a id="L1211" href="#L1211">1211</a><a id="L1212" href="#L1212">1212</a><a id="L1213" href="#L1213">1213</a><a id="L1214" href="#L1214">1214</a><a id="L1215" href="#L1215">1215</a><a id="L1216" href="#L1216">1216</a><a id="L1217" href="#L1217">1217</a><a id="L1218" href="#L1218">1218</a><a id="L1219" href="#L1219">1219</a><a id="L1220" href="#L1220">1220</a><a id="L1221" href="#L1221">1221</a><a id="L1222" href="#L1222">1222</a><a id="L1223" href="#L1223">1223</a><a id="L1224" href="#L1224">1224</a><a id="L1225" href="#L1225">1225</a><a id="L1226" href="#L1226">1226</a><a id="L1227" href="#L1227">1227</a><a id="L1228" href="#L1228">1228</a><a id="L1229" href="#L1229">1229</a><a id="L1230" href="#L1230">1230</a><a id="L1231" href="#L1231">1231</a><a id="L1232" href="#L1232">1232</a><a id="L1233" href="#L1233">1233</a><a id="L1234" href="#L1234">1234</a><a id="L1235" href="#L1235">1235</a><a id="L1236" href="#L1236">1236</a><a id="L1237" href="#L1237">1237</a><a id="L1238" href="#L1238">1238</a><a id="L1239" href="#L1239">1239</a><a id="L1240" href="#L1240">1240</a><a id="L1241" href="#L1241">1241</a><a id="L1242" href="#L1242">1242</a><a id="L1243" href="#L1243">1243</a><a id="L1244" href="#L1244">1244</a><a id="L1245" href="#L1245">1245</a><a id="L1246" href="#L1246">1246</a><a id="L1247" href="#L1247">1247</a><a id="L1248" href="#L1248">1248</a><a id="L1249" href="#L1249">1249</a><a id="L1250" href="#L1250">1250</a><a id="L1251" href="#L1251">1251</a><a id="L1252" href="#L1252">1252</a><a id="L1253" href="#L1253">1253</a><a id="L1254" href="#L1254">1254</a><a id="L1255" href="#L1255">1255</a><a id="L1256" href="#L1256">1256</a><a id="L1257" href="#L1257">1257</a><a id="L1258" href="#L1258">1258</a><a id="L1259" href="#L1259">1259</a><a id="L1260" href="#L1260">1260</a><a id="L1261" href="#L1261">1261</a><a id="L1262" href="#L1262">1262</a><a id="L1263" href="#L1263">1263</a><a id="L1264" href="#L1264">1264</a><a id="L1265" href="#L1265">1265</a><a id="L1266" href="#L1266">1266</a><a id="L1267" href="#L1267">1267</a><a id="L1268" href="#L1268">1268</a><a id="L1269" href="#L1269">1269</a><a id="L1270" href="#L1270">1270</a><a id="L1271" href="#L1271">1271</a><a id="L1272" href="#L1272">1272</a><a id="L1273" href="#L1273">1273</a><a id="L1274" href="#L1274">1274</a><a id="L1275" href="#L1275">1275</a><a id="L1276" href="#L1276">1276</a><a id="L1277" href="#L1277">1277</a><a id="L1278" href="#L1278">1278</a><a id="L1279" href="#L1279">1279</a><a id="L1280" href="#L1280">1280</a><a id="L1281" href="#L1281">1281</a><a id="L1282" href="#L1282">1282</a><a id="L1283" href="#L1283">1283</a><a id="L1284" href="#L1284">1284</a><a id="L1285" href="#L1285">1285</a><a id="L1286" href="#L1286">1286</a><a id="L1287" href="#L1287">1287</a><a id="L1288" href="#L1288">1288</a><a id="L1289" href="#L1289">1289</a><a id="L1290" href="#L1290">1290</a><a id="L1291" href="#L1291">1291</a><a id="L1292" href="#L1292">1292</a><a id="L1293" href="#L1293">1293</a><a id="L1294" href="#L1294">1294</a><a id="L1295" href="#L1295">1295</a><a id="L1296" href="#L1296">1296</a><a id="L1297" href="#L1297">1297</a><a id="L1298" href="#L1298">1298</a><a id="L1299" href="#L1299">1299</a><a id="L1300" href="#L1300">1300</a><a id="L1301" href="#L1301">1301</a><a id="L1302" href="#L1302">1302</a><a id="L1303" href="#L1303">1303</a><a id="L1304" href="#L1304">1304</a><a id="L1305" href="#L1305">1305</a><a id="L1306" href="#L1306">1306</a><a id="L1307" href="#L1307">1307</a><a id="L1308" href="#L1308">1308</a><a id="L1309" href="#L1309">1309</a><a id="L1310" href="#L1310">1310</a><a id="L1311" href="#L1311">1311</a><a id="L1312" href="#L1312">1312</a><a id="L1313" href="#L1313">1313</a><a id="L1314" href="#L1314">1314</a><a id="L1315" href="#L1315">1315</a><a id="L1316" href="#L1316">1316</a><a id="L1317" href="#L1317">1317</a><a id="L1318" href="#L1318">1318</a><a id="L1319" href="#L1319">1319</a><a id="L1320" href="#L1320">1320</a><a id="L1321" href="#L1321">1321</a><a id="L1322" href="#L1322">1322</a><a id="L1323" href="#L1323">1323</a><a id="L1324" href="#L1324">1324</a><a id="L1325" href="#L1325">1325</a><a id="L1326" href="#L1326">1326</a><a id="L1327" href="#L1327">1327</a><a id="L1328" href="#L1328">1328</a><a id="L1329" href="#L1329">1329</a><a id="L1330" href="#L1330">1330</a><a id="L1331" href="#L1331">1331</a><a id="L1332" href="#L1332">1332</a><a id="L1333" href="#L1333">1333</a><a id="L1334" href="#L1334">1334</a><a id="L1335" href="#L1335">1335</a><a id="L1336" href="#L1336">1336</a><a id="L1337" href="#L1337">1337</a><a id="L1338" href="#L1338">1338</a><a id="L1339" href="#L1339">1339</a><a id="L1340" href="#L1340">1340</a><a id="L1341" href="#L1341">1341</a><a id="L1342" href="#L1342">1342</a><a id="L1343" href="#L1343">1343</a><a id="L1344" href="#L1344">1344</a><a id="L1345" href="#L1345">1345</a><a id="L1346" href="#L1346">1346</a><a id="L1347" href="#L1347">1347</a><a id="L1348" href="#L1348">1348</a><a id="L1349" href="#L1349">1349</a><a id="L1350" href="#L1350">1350</a><a id="L1351" href="#L1351">1351</a><a id="L1352" href="#L1352">1352</a><a id="L1353" href="#L1353">1353</a><a id="L1354" href="#L1354">1354</a><a id="L1355" href="#L1355">1355</a><a id="L1356" href="#L1356">1356</a><a id="L1357" href="#L1357">1357</a><a id="L1358" href="#L1358">1358</a><a id="L1359" href="#L1359">1359</a><a id="L1360" href="#L1360">1360</a><a id="L1361" href="#L1361">1361</a><a id="L1362" href="#L1362">1362</a><a id="L1363" href="#L1363">1363</a><a id="L1364" href="#L1364">1364</a><a id="L1365" href="#L1365">1365</a><a id="L1366" href="#L1366">1366</a><a id="L1367" href="#L1367">1367</a><a id="L1368" href="#L1368">1368</a><a id="L1369" href="#L1369">1369</a><a id="L1370" href="#L1370">1370</a><a id="L1371" href="#L1371">1371</a><a id="L1372" href="#L1372">1372</a><a id="L1373" href="#L1373">1373</a><a id="L1374" href="#L1374">1374</a><a id="L1375" href="#L1375">1375</a><a id="L1376" href="#L1376">1376</a><a id="L1377" href="#L1377">1377</a><a id="L1378" href="#L1378">1378</a><a id="L1379" href="#L1379">1379</a><a id="L1380" href="#L1380">1380</a><a id="L1381" href="#L1381">1381</a><a id="L1382" href="#L1382">1382</a><a id="L1383" href="#L1383">1383</a><a id="L1384" href="#L1384">1384</a><a id="L1385" href="#L1385">1385</a><a id="L1386" href="#L1386">1386</a><a id="L1387" href="#L1387">1387</a><a id="L1388" href="#L1388">1388</a><a id="L1389" href="#L1389">1389</a><a id="L1390" href="#L1390">1390</a><a id="L1391" href="#L1391">1391</a><a id="L1392" href="#L1392">1392</a><a id="L1393" href="#L1393">1393</a><a id="L1394" href="#L1394">1394</a><a id="L1395" href="#L1395">1395</a><a id="L1396" href="#L1396">1396</a><a id="L1397" href="#L1397">1397</a><a id="L1398" href="#L1398">1398</a><a id="L1399" href="#L1399">1399</a><a id="L1400" href="#L1400">1400</a><a id="L1401" href="#L1401">1401</a><a id="L1402" href="#L1402">1402</a><a id="L1403" href="#L1403">1403</a><a id="L1404" href="#L1404">1404</a><a id="L1405" href="#L1405">1405</a><a id="L1406" href="#L1406">1406</a><a id="L1407" href="#L1407">1407</a><a id="L1408" href="#L1408">1408</a><a id="L1409" href="#L1409">1409</a><a id="L1410" href="#L1410">1410</a><a id="L1411" href="#L1411">1411</a><a id="L1412" href="#L1412">1412</a><a id="L1413" href="#L1413">1413</a><a id="L1414" href="#L1414">1414</a><a id="L1415" href="#L1415">1415</a><a id="L1416" href="#L1416">1416</a><a id="L1417" href="#L1417">1417</a><a id="L1418" href="#L1418">1418</a><a id="L1419" href="#L1419">1419</a><a id="L1420" href="#L1420">1420</a><a id="L1421" href="#L1421">1421</a><a id="L1422" href="#L1422">1422</a><a id="L1423" href="#L1423">1423</a><a id="L1424" href="#L1424">1424</a><a id="L1425" href="#L1425">1425</a><a id="L1426" href="#L1426">1426</a><a id="L1427" href="#L1427">1427</a><a id="L1428" href="#L1428">1428</a><a id="L1429" href="#L1429">1429</a><a id="L1430" href="#L1430">1430</a><a id="L1431" href="#L1431">1431</a><a id="L1432" href="#L1432">1432</a><a id="L1433" href="#L1433">1433</a><a id="L1434" href="#L1434">1434</a><a id="L1435" href="#L1435">1435</a><a id="L1436" href="#L1436">1436</a><a id="L1437" href="#L1437">1437</a><a id="L1438" href="#L1438">1438</a><a id="L1439" href="#L1439">1439</a><a id="L1440" href="#L1440">1440</a><a id="L1441" href="#L1441">1441</a><a id="L1442" href="#L1442">1442</a><a id="L1443" href="#L1443">1443</a><a id="L1444" href="#L1444">1444</a><a id="L1445" href="#L1445">1445</a><a id="L1446" href="#L1446">1446</a><a id="L1447" href="#L1447">1447</a><a id="L1448" href="#L1448">1448</a><a id="L1449" href="#L1449">1449</a><a id="L1450" href="#L1450">1450</a><a id="L1451" href="#L1451">1451</a><a id="L1452" href="#L1452">1452</a><a id="L1453" href="#L1453">1453</a><a id="L1454" href="#L1454">1454</a><a id="L1455" href="#L1455">1455</a><a id="L1456" href="#L1456">1456</a><a id="L1457" href="#L1457">1457</a><a id="L1458" href="#L1458">1458</a><a id="L1459" href="#L1459">1459</a><a id="L1460" href="#L1460">1460</a><a id="L1461" href="#L1461">1461</a><a id="L1462" href="#L1462">1462</a><a id="L1463" href="#L1463">1463</a><a id="L1464" href="#L1464">1464</a><a id="L1465" href="#L1465">1465</a><a id="L1466" href="#L1466">1466</a><a id="L1467" href="#L1467">1467</a><a id="L1468" href="#L1468">1468</a><a id="L1469" href="#L1469">1469</a><a id="L1470" href="#L1470">1470</a><a id="L1471" href="#L1471">1471</a><a id="L1472" href="#L1472">1472</a><a id="L1473" href="#L1473">1473</a><a id="L1474" href="#L1474">1474</a><a id="L1475" href="#L1475">1475</a><a id="L1476" href="#L1476">1476</a><a id="L1477" href="#L1477">1477</a><a id="L1478" href="#L1478">1478</a><a id="L1479" href="#L1479">1479</a><a id="L1480" href="#L1480">1480</a><a id="L1481" href="#L1481">1481</a><a id="L1482" href="#L1482">1482</a><a id="L1483" href="#L1483">1483</a><a id="L1484" href="#L1484">1484</a><a id="L1485" href="#L1485">1485</a><a id="L1486" href="#L1486">1486</a><a id="L1487" href="#L1487">1487</a><a id="L1488" href="#L1488">1488</a><a id="L1489" href="#L1489">1489</a><a id="L1490" href="#L1490">1490</a><a id="L1491" href="#L1491">1491</a><a id="L1492" href="#L1492">1492</a><a id="L1493" href="#L1493">1493</a><a id="L1494" href="#L1494">1494</a><a id="L1495" href="#L1495">1495</a><a id="L1496" href="#L1496">1496</a><a id="L1497" href="#L1497">1497</a><a id="L1498" href="#L1498">1498</a><a id="L1499" href="#L1499">1499</a><a id="L1500" href="#L1500">1500</a><a id="L1501" href="#L1501">1501</a><a id="L1502" href="#L1502">1502</a><a id="L1503" href="#L1503">1503</a><a id="L1504" href="#L1504">1504</a><a id="L1505" href="#L1505">1505</a><a id="L1506" href="#L1506">1506</a><a id="L1507" href="#L1507">1507</a><a id="L1508" href="#L1508">1508</a><a id="L1509" href="#L1509">1509</a><a id="L1510" href="#L1510">1510</a><a id="L1511" href="#L1511">1511</a><a id="L1512" href="#L1512">1512</a><a id="L1513" href="#L1513">1513</a><a id="L1514" href="#L1514">1514</a><a id="L1515" href="#L1515">1515</a><a id="L1516" href="#L1516">1516</a><a id="L1517" href="#L1517">1517</a><a id="L1518" href="#L1518">1518</a><a id="L1519" href="#L1519">1519</a><a id="L1520" href="#L1520">1520</a><a id="L1521" href="#L1521">1521</a><a id="L1522" href="#L1522">1522</a><a id="L1523" href="#L1523">1523</a><a id="L1524" href="#L1524">1524</a><a id="L1525" href="#L1525">1525</a><a id="L1526" href="#L1526">1526</a><a id="L1527" href="#L1527">1527</a><a id="L1528" href="#L1528">1528</a><a id="L1529" href="#L1529">1529</a><a id="L1530" href="#L1530">1530</a><a id="L1531" href="#L1531">1531</a><a id="L1532" href="#L1532">1532</a><a id="L1533" href="#L1533">1533</a><a id="L1534" href="#L1534">1534</a><a id="L1535" href="#L1535">1535</a><a id="L1536" href="#L1536">1536</a><a id="L1537" href="#L1537">1537</a><a id="L1538" href="#L1538">1538</a><a id="L1539" href="#L1539">1539</a><a id="L1540" href="#L1540">1540</a><a id="L1541" href="#L1541">1541</a><a id="L1542" href="#L1542">1542</a><a id="L1543" href="#L1543">1543</a><a id="L1544" href="#L1544">1544</a><a id="L1545" href="#L1545">1545</a><a id="L1546" href="#L1546">1546</a><a id="L1547" href="#L1547">1547</a><a id="L1548" href="#L1548">1548</a><a id="L1549" href="#L1549">1549</a><a id="L1550" href="#L1550">1550</a><a id="L1551" href="#L1551">1551</a><a id="L1552" href="#L1552">1552</a><a id="L1553" href="#L1553">1553</a><a id="L1554" href="#L1554">1554</a><a id="L1555" href="#L1555">1555</a><a id="L1556" href="#L1556">1556</a><a id="L1557" href="#L1557">1557</a><a id="L1558" href="#L1558">1558</a><a id="L1559" href="#L1559">1559</a><a id="L1560" href="#L1560">1560</a><a id="L1561" href="#L1561">1561</a><a id="L1562" href="#L1562">1562</a><a id="L1563" href="#L1563">1563</a><a id="L1564" href="#L1564">1564</a><a id="L1565" href="#L1565">1565</a><a id="L1566" href="#L1566">1566</a><a id="L1567" href="#L1567">1567</a><a id="L1568" href="#L1568">1568</a><a id="L1569" href="#L1569">1569</a><a id="L1570" href="#L1570">1570</a><a id="L1571" href="#L1571">1571</a><a id="L1572" href="#L1572">1572</a><a id="L1573" href="#L1573">1573</a><a id="L1574" href="#L1574">1574</a><a id="L1575" href="#L1575">1575</a><a id="L1576" href="#L1576">1576</a><a id="L1577" href="#L1577">1577</a><a id="L1578" href="#L1578">1578</a><a id="L1579" href="#L1579">1579</a><a id="L1580" href="#L1580">1580</a><a id="L1581" href="#L1581">1581</a><a id="L1582" href="#L1582">1582</a><a id="L1583" href="#L1583">1583</a><a id="L1584" href="#L1584">1584</a><a id="L1585" href="#L1585">1585</a><a id="L1586" href="#L1586">1586</a><a id="L1587" href="#L1587">1587</a><a id="L1588" href="#L1588">1588</a><a id="L1589" href="#L1589">1589</a><a id="L1590" href="#L1590">1590</a><a id="L1591" href="#L1591">1591</a><a id="L1592" href="#L1592">1592</a><a id="L1593" href="#L1593">1593</a><a id="L1594" href="#L1594">1594</a><a id="L1595" href="#L1595">1595</a><a id="L1596" href="#L1596">1596</a><a id="L1597" href="#L1597">1597</a><a id="L1598" href="#L1598">1598</a><a id="L1599" href="#L1599">1599</a><a id="L1600" href="#L1600">1600</a><a id="L1601" href="#L1601">1601</a><a id="L1602" href="#L1602">1602</a><a id="L1603" href="#L1603">1603</a><a id="L1604" href="#L1604">1604</a><a id="L1605" href="#L1605">1605</a><a id="L1606" href="#L1606">1606</a><a id="L1607" href="#L1607">1607</a><a id="L1608" href="#L1608">1608</a><a id="L1609" href="#L1609">1609</a><a id="L1610" href="#L1610">1610</a><a id="L1611" href="#L1611">1611</a><a id="L1612" href="#L1612">1612</a><a id="L1613" href="#L1613">1613</a><a id="L1614" href="#L1614">1614</a><a id="L1615" href="#L1615">1615</a><a id="L1616" href="#L1616">1616</a><a id="L1617" href="#L1617">1617</a><a id="L1618" href="#L1618">1618</a><a id="L1619" href="#L1619">1619</a><a id="L1620" href="#L1620">1620</a><a id="L1621" href="#L1621">1621</a><a id="L1622" href="#L1622">1622</a><a id="L1623" href="#L1623">1623</a><a id="L1624" href="#L1624">1624</a><a id="L1625" href="#L1625">1625</a><a id="L1626" href="#L1626">1626</a><a id="L1627" href="#L1627">1627</a><a id="L1628" href="#L1628">1628</a><a id="L1629" href="#L1629">1629</a><a id="L1630" href="#L1630">1630</a><a id="L1631" href="#L1631">1631</a><a id="L1632" href="#L1632">1632</a><a id="L1633" href="#L1633">1633</a><a id="L1634" href="#L1634">1634</a><a id="L1635" href="#L1635">1635</a><a id="L1636" href="#L1636">1636</a><a id="L1637" href="#L1637">1637</a><a id="L1638" href="#L1638">1638</a><a id="L1639" href="#L1639">1639</a><a id="L1640" href="#L1640">1640</a><a id="L1641" href="#L1641">1641</a><a id="L1642" href="#L1642">1642</a><a id="L1643" href="#L1643">1643</a><a id="L1644" href="#L1644">1644</a><a id="L1645" href="#L1645">1645</a><a id="L1646" href="#L1646">1646</a><a id="L1647" href="#L1647">1647</a><a id="L1648" href="#L1648">1648</a><a id="L1649" href="#L1649">1649</a><a id="L1650" href="#L1650">1650</a><a id="L1651" href="#L1651">1651</a><a id="L1652" href="#L1652">1652</a><a id="L1653" href="#L1653">1653</a><a id="L1654" href="#L1654">1654</a><a id="L1655" href="#L1655">1655</a><a id="L1656" href="#L1656">1656</a><a id="L1657" href="#L1657">1657</a><a id="L1658" href="#L1658">1658</a><a id="L1659" href="#L1659">1659</a><a id="L1660" href="#L1660">1660</a><a id="L1661" href="#L1661">1661</a><a id="L1662" href="#L1662">1662</a><a id="L1663" href="#L1663">1663</a><a id="L1664" href="#L1664">1664</a><a id="L1665" href="#L1665">1665</a><a id="L1666" href="#L1666">1666</a><a id="L1667" href="#L1667">1667</a><a id="L1668" href="#L1668">1668</a><a id="L1669" href="#L1669">1669</a><a id="L1670" href="#L1670">1670</a><a id="L1671" href="#L1671">1671</a><a id="L1672" href="#L1672">1672</a><a id="L1673" href="#L1673">1673</a><a id="L1674" href="#L1674">1674</a><a id="L1675" href="#L1675">1675</a><a id="L1676" href="#L1676">1676</a><a id="L1677" href="#L1677">1677</a><a id="L1678" href="#L1678">1678</a><a id="L1679" href="#L1679">1679</a><a id="L1680" href="#L1680">1680</a><a id="L1681" href="#L1681">1681</a><a id="L1682" href="#L1682">1682</a><a id="L1683" href="#L1683">1683</a><a id="L1684" href="#L1684">1684</a><a id="L1685" href="#L1685">1685</a><a id="L1686" href="#L1686">1686</a><a id="L1687" href="#L1687">1687</a><a id="L1688" href="#L1688">1688</a><a id="L1689" href="#L1689">1689</a><a id="L1690" href="#L1690">1690</a><a id="L1691" href="#L1691">1691</a><a id="L1692" href="#L1692">1692</a><a id="L1693" href="#L1693">1693</a><a id="L1694" href="#L1694">1694</a><a id="L1695" href="#L1695">1695</a><a id="L1696" href="#L1696">1696</a><a id="L1697" href="#L1697">1697</a><a id="L1698" href="#L1698">1698</a><a id="L1699" href="#L1699">1699</a><a id="L1700" href="#L1700">1700</a><a id="L1701" href="#L1701">1701</a><a id="L1702" href="#L1702">1702</a><a id="L1703" href="#L1703">1703</a><a id="L1704" href="#L1704">1704</a><a id="L1705" href="#L1705">1705</a><a id="L1706" href="#L1706">1706</a><a id="L1707" href="#L1707">1707</a><a id="L1708" href="#L1708">1708</a><a id="L1709" href="#L1709">1709</a><a id="L1710" href="#L1710">1710</a><a id="L1711" href="#L1711">1711</a><a id="L1712" href="#L1712">1712</a><a id="L1713" href="#L1713">1713</a><a id="L1714" href="#L1714">1714</a><a id="L1715" href="#L1715">1715</a><a id="L1716" href="#L1716">1716</a><a id="L1717" href="#L1717">1717</a><a id="L1718" href="#L1718">1718</a><a id="L1719" href="#L1719">1719</a><a id="L1720" href="#L1720">1720</a><a id="L1721" href="#L1721">1721</a><a id="L1722" href="#L1722">1722</a><a id="L1723" href="#L1723">1723</a><a id="L1724" href="#L1724">1724</a><a id="L1725" href="#L1725">1725</a><a id="L1726" href="#L1726">1726</a><a id="L1727" href="#L1727">1727</a><a id="L1728" href="#L1728">1728</a><a id="L1729" href="#L1729">1729</a><a id="L1730" href="#L1730">1730</a><a id="L1731" href="#L1731">1731</a><a id="L1732" href="#L1732">1732</a><a id="L1733" href="#L1733">1733</a><a id="L1734" href="#L1734">1734</a><a id="L1735" href="#L1735">1735</a><a id="L1736" href="#L1736">1736</a><a id="L1737" href="#L1737">1737</a><a id="L1738" href="#L1738">1738</a><a id="L1739" href="#L1739">1739</a><a id="L1740" href="#L1740">1740</a><a id="L1741" href="#L1741">1741</a><a id="L1742" href="#L1742">1742</a><a id="L1743" href="#L1743">1743</a><a id="L1744" href="#L1744">1744</a><a id="L1745" href="#L1745">1745</a><a id="L1746" href="#L1746">1746</a><a id="L1747" href="#L1747">1747</a><a id="L1748" href="#L1748">1748</a><a id="L1749" href="#L1749">1749</a><a id="L1750" href="#L1750">1750</a><a id="L1751" href="#L1751">1751</a><a id="L1752" href="#L1752">1752</a><a id="L1753" href="#L1753">1753</a><a id="L1754" href="#L1754">1754</a><a id="L1755" href="#L1755">1755</a><a id="L1756" href="#L1756">1756</a><a id="L1757" href="#L1757">1757</a><a id="L1758" href="#L1758">1758</a><a id="L1759" href="#L1759">1759</a><a id="L1760" href="#L1760">1760</a><a id="L1761" href="#L1761">1761</a><a id="L1762" href="#L1762">1762</a><a id="L1763" href="#L1763">1763</a><a id="L1764" href="#L1764">1764</a><a id="L1765" href="#L1765">1765</a><a id="L1766" href="#L1766">1766</a><a id="L1767" href="#L1767">1767</a><a id="L1768" href="#L1768">1768</a><a id="L1769" href="#L1769">1769</a><a id="L1770" href="#L1770">1770</a><a id="L1771" href="#L1771">1771</a><a id="L1772" href="#L1772">1772</a><a id="L1773" href="#L1773">1773</a><a id="L1774" href="#L1774">1774</a><a id="L1775" href="#L1775">1775</a><a id="L1776" href="#L1776">1776</a><a id="L1777" href="#L1777">1777</a><a id="L1778" href="#L1778">1778</a><a id="L1779" href="#L1779">1779</a><a id="L1780" href="#L1780">1780</a><a id="L1781" href="#L1781">1781</a><a id="L1782" href="#L1782">1782</a><a id="L1783" href="#L1783">1783</a><a id="L1784" href="#L1784">1784</a><a id="L1785" href="#L1785">1785</a><a id="L1786" href="#L1786">1786</a><a id="L1787" href="#L1787">1787</a><a id="L1788" href="#L1788">1788</a><a id="L1789" href="#L1789">1789</a><a id="L1790" href="#L1790">1790</a><a id="L1791" href="#L1791">1791</a><a id="L1792" href="#L1792">1792</a><a id="L1793" href="#L1793">1793</a><a id="L1794" href="#L1794">1794</a><a id="L1795" href="#L1795">1795</a><a id="L1796" href="#L1796">1796</a><a id="L1797" href="#L1797">1797</a><a id="L1798" href="#L1798">1798</a><a id="L1799" href="#L1799">1799</a><a id="L1800" href="#L1800">1800</a><a id="L1801" href="#L1801">1801</a><a id="L1802" href="#L1802">1802</a><a id="L1803" href="#L1803">1803</a><a id="L1804" href="#L1804">1804</a><a id="L1805" href="#L1805">1805</a><a id="L1806" href="#L1806">1806</a><a id="L1807" href="#L1807">1807</a><a id="L1808" href="#L1808">1808</a><a id="L1809" href="#L1809">1809</a><a id="L1810" href="#L1810">1810</a><a id="L1811" href="#L1811">1811</a><a id="L1812" href="#L1812">1812</a><a id="L1813" href="#L1813">1813</a><a id="L1814" href="#L1814">1814</a><a id="L1815" href="#L1815">1815</a><a id="L1816" href="#L1816">1816</a><a id="L1817" href="#L1817">1817</a><a id="L1818" href="#L1818">1818</a><a id="L1819" href="#L1819">1819</a><a id="L1820" href="#L1820">1820</a><a id="L1821" href="#L1821">1821</a><a id="L1822" href="#L1822">1822</a><a id="L1823" href="#L1823">1823</a><a id="L1824" href="#L1824">1824</a><a id="L1825" href="#L1825">1825</a><a id="L1826" href="#L1826">1826</a><a id="L1827" href="#L1827">1827</a><a id="L1828" href="#L1828">1828</a><a id="L1829" href="#L1829">1829</a><a id="L1830" href="#L1830">1830</a><a id="L1831" href="#L1831">1831</a><a id="L1832" href="#L1832">1832</a><a id="L1833" href="#L1833">1833</a><a id="L1834" href="#L1834">1834</a><a id="L1835" href="#L1835">1835</a><a id="L1836" href="#L1836">1836</a><a id="L1837" href="#L1837">1837</a><a id="L1838" href="#L1838">1838</a><a id="L1839" href="#L1839">1839</a><a id="L1840" href="#L1840">1840</a><a id="L1841" href="#L1841">1841</a><a id="L1842" href="#L1842">1842</a><a id="L1843" href="#L1843">1843</a><a id="L1844" href="#L1844">1844</a><a id="L1845" href="#L1845">1845</a><a id="L1846" href="#L1846">1846</a><a id="L1847" href="#L1847">1847</a><a id="L1848" href="#L1848">1848</a><a id="L1849" href="#L1849">1849</a><a id="L1850" href="#L1850">1850</a><a id="L1851" href="#L1851">1851</a><a id="L1852" href="#L1852">1852</a><a id="L1853" href="#L1853">1853</a><a id="L1854" href="#L1854">1854</a><a id="L1855" href="#L1855">1855</a><a id="L1856" href="#L1856">1856</a><a id="L1857" href="#L1857">1857</a><a id="L1858" href="#L1858">1858</a><a id="L1859" href="#L1859">1859</a><a id="L1860" href="#L1860">1860</a><a id="L1861" href="#L1861">1861</a><a id="L1862" href="#L1862">1862</a><a id="L1863" href="#L1863">1863</a><a id="L1864" href="#L1864">1864</a><a id="L1865" href="#L1865">1865</a><a id="L1866" href="#L1866">1866</a><a id="L1867" href="#L1867">1867</a><a id="L1868" href="#L1868">1868</a><a id="L1869" href="#L1869">1869</a><a id="L1870" href="#L1870">1870</a><a id="L1871" href="#L1871">1871</a><a id="L1872" href="#L1872">1872</a><a id="L1873" href="#L1873">1873</a><a id="L1874" href="#L1874">1874</a><a id="L1875" href="#L1875">1875</a><a id="L1876" href="#L1876">1876</a><a id="L1877" href="#L1877">1877</a><a id="L1878" href="#L1878">1878</a><a id="L1879" href="#L1879">1879</a><a id="L1880" href="#L1880">1880</a><a id="L1881" href="#L1881">1881</a><a id="L1882" href="#L1882">1882</a><a id="L1883" href="#L1883">1883</a><a id="L1884" href="#L1884">1884</a><a id="L1885" href="#L1885">1885</a><a id="L1886" href="#L1886">1886</a><a id="L1887" href="#L1887">1887</a><a id="L1888" href="#L1888">1888</a><a id="L1889" href="#L1889">1889</a><a id="L1890" href="#L1890">1890</a><a id="L1891" href="#L1891">1891</a><a id="L1892" href="#L1892">1892</a><a id="L1893" href="#L1893">1893</a><a id="L1894" href="#L1894">1894</a><a id="L1895" href="#L1895">1895</a><a id="L1896" href="#L1896">1896</a><a id="L1897" href="#L1897">1897</a><a id="L1898" href="#L1898">1898</a><a id="L1899" href="#L1899">1899</a><a id="L1900" href="#L1900">1900</a><a id="L1901" href="#L1901">1901</a><a id="L1902" href="#L1902">1902</a><a id="L1903" href="#L1903">1903</a><a id="L1904" href="#L1904">1904</a><a id="L1905" href="#L1905">1905</a><a id="L1906" href="#L1906">1906</a><a id="L1907" href="#L1907">1907</a><a id="L1908" href="#L1908">1908</a><a id="L1909" href="#L1909">1909</a><a id="L1910" href="#L1910">1910</a><a id="L1911" href="#L1911">1911</a><a id="L1912" href="#L1912">1912</a><a id="L1913" href="#L1913">1913</a><a id="L1914" href="#L1914">1914</a><a id="L1915" href="#L1915">1915</a><a id="L1916" href="#L1916">1916</a><a id="L1917" href="#L1917">1917</a><a id="L1918" href="#L1918">1918</a><a id="L1919" href="#L1919">1919</a><a id="L1920" href="#L1920">1920</a><a id="L1921" href="#L1921">1921</a><a id="L1922" href="#L1922">1922</a><a id="L1923" href="#L1923">1923</a><a id="L1924" href="#L1924">1924</a><a id="L1925" href="#L1925">1925</a><a id="L1926" href="#L1926">1926</a><a id="L1927" href="#L1927">1927</a><a id="L1928" href="#L1928">1928</a><a id="L1929" href="#L1929">1929</a><a id="L1930" href="#L1930">1930</a><a id="L1931" href="#L1931">1931</a><a id="L1932" href="#L1932">1932</a><a id="L1933" href="#L1933">1933</a><a id="L1934" href="#L1934">1934</a><a id="L1935" href="#L1935">1935</a><a id="L1936" href="#L1936">1936</a><a id="L1937" href="#L1937">1937</a><a id="L1938" href="#L1938">1938</a><a id="L1939" href="#L1939">1939</a><a id="L1940" href="#L1940">1940</a><a id="L1941" href="#L1941">1941</a><a id="L1942" href="#L1942">1942</a><a id="L1943" href="#L1943">1943</a><a id="L1944" href="#L1944">1944</a><a id="L1945" href="#L1945">1945</a><a id="L1946" href="#L1946">1946</a><a id="L1947" href="#L1947">1947</a><a id="L1948" href="#L1948">1948</a><a id="L1949" href="#L1949">1949</a><a id="L1950" href="#L1950">1950</a><a id="L1951" href="#L1951">1951</a><a id="L1952" href="#L1952">1952</a><a id="L1953" href="#L1953">1953</a><a id="L1954" href="#L1954">1954</a><a id="L1955" href="#L1955">1955</a><a id="L1956" href="#L1956">1956</a><a id="L1957" href="#L1957">1957</a><a id="L1958" href="#L1958">1958</a><a id="L1959" href="#L1959">1959</a><a id="L1960" href="#L1960">1960</a><a id="L1961" href="#L1961">1961</a><a id="L1962" href="#L1962">1962</a><a id="L1963" href="#L1963">1963</a><a id="L1964" href="#L1964">1964</a><a id="L1965" href="#L1965">1965</a><a id="L1966" href="#L1966">1966</a><a id="L1967" href="#L1967">1967</a><a id="L1968" href="#L1968">1968</a><a id="L1969" href="#L1969">1969</a><a id="L1970" href="#L1970">1970</a><a id="L1971" href="#L1971">1971</a><a id="L1972" href="#L1972">1972</a><a id="L1973" href="#L1973">1973</a><a id="L1974" href="#L1974">1974</a><a id="L1975" href="#L1975">1975</a><a id="L1976" href="#L1976">1976</a><a id="L1977" href="#L1977">1977</a><a id="L1978" href="#L1978">1978</a><a id="L1979" href="#L1979">1979</a><a id="L1980" href="#L1980">1980</a><a id="L1981" href="#L1981">1981</a><a id="L1982" href="#L1982">1982</a><a id="L1983" href="#L1983">1983</a><a id="L1984" href="#L1984">1984</a><a id="L1985" href="#L1985">1985</a><a id="L1986" href="#L1986">1986</a><a id="L1987" href="#L1987">1987</a><a id="L1988" href="#L1988">1988</a><a id="L1989" href="#L1989">1989</a><a id="L1990" href="#L1990">1990</a><a id="L1991" href="#L1991">1991</a><a id="L1992" href="#L1992">1992</a><a id="L1993" href="#L1993">1993</a><a id="L1994" href="#L1994">1994</a><a id="L1995" href="#L1995">1995</a><a id="L1996" href="#L1996">1996</a><a id="L1997" href="#L1997">1997</a><a id="L1998" href="#L1998">1998</a><a id="L1999" href="#L1999">1999</a><a id="L2000" href="#L2000">2000</a><a id="L2001" href="#L2001">2001</a><a id="L2002" href="#L2002">2002</a><a id="L2003" href="#L2003">2003</a><a id="L2004" href="#L2004">2004</a><a id="L2005" href="#L2005">2005</a><a id="L2006" href="#L2006">2006</a><a id="L2007" href="#L2007">2007</a><a id="L2008" href="#L2008">2008</a><a id="L2009" href="#L2009">2009</a><a id="L2010" href="#L2010">2010</a><a id="L2011" href="#L2011">2011</a><a id="L2012" href="#L2012">2012</a><a id="L2013" href="#L2013">2013</a><a id="L2014" href="#L2014">2014</a><a id="L2015" href="#L2015">2015</a><a id="L2016" href="#L2016">2016</a><a id="L2017" href="#L2017">2017</a><a id="L2018" href="#L2018">2018</a><a id="L2019" href="#L2019">2019</a><a id="L2020" href="#L2020">2020</a><a id="L2021" href="#L2021">2021</a><a id="L2022" href="#L2022">2022</a><a id="L2023" href="#L2023">2023</a><a id="L2024" href="#L2024">2024</a><a id="L2025" href="#L2025">2025</a><a id="L2026" href="#L2026">2026</a><a id="L2027" href="#L2027">2027</a><a id="L2028" href="#L2028">2028</a><a id="L2029" href="#L2029">2029</a><a id="L2030" href="#L2030">2030</a><a id="L2031" href="#L2031">2031</a><a id="L2032" href="#L2032">2032</a><a id="L2033" href="#L2033">2033</a><a id="L2034" href="#L2034">2034</a><a id="L2035" href="#L2035">2035</a><a id="L2036" href="#L2036">2036</a><a id="L2037" href="#L2037">2037</a><a id="L2038" href="#L2038">2038</a><a id="L2039" href="#L2039">2039</a><a id="L2040" href="#L2040">2040</a><a id="L2041" href="#L2041">2041</a><a id="L2042" href="#L2042">2042</a><a id="L2043" href="#L2043">2043</a><a id="L2044" href="#L2044">2044</a><a id="L2045" href="#L2045">2045</a><a id="L2046" href="#L2046">2046</a><a id="L2047" href="#L2047">2047</a><a id="L2048" href="#L2048">2048</a><a id="L2049" href="#L2049">2049</a><a id="L2050" href="#L2050">2050</a><a id="L2051" href="#L2051">2051</a><a id="L2052" href="#L2052">2052</a><a id="L2053" href="#L2053">2053</a><a id="L2054" href="#L2054">2054</a><a id="L2055" href="#L2055">2055</a><a id="L2056" href="#L2056">2056</a><a id="L2057" href="#L2057">2057</a><a id="L2058" href="#L2058">2058</a><a id="L2059" href="#L2059">2059</a><a id="L2060" href="#L2060">2060</a><a id="L2061" href="#L2061">2061</a><a id="L2062" href="#L2062">2062</a><a id="L2063" href="#L2063">2063</a><a id="L2064" href="#L2064">2064</a><a id="L2065" href="#L2065">2065</a><a id="L2066" href="#L2066">2066</a><a id="L2067" href="#L2067">2067</a><a id="L2068" href="#L2068">2068</a><a id="L2069" href="#L2069">2069</a><a id="L2070" href="#L2070">2070</a><a id="L2071" href="#L2071">2071</a><a id="L2072" href="#L2072">2072</a><a id="L2073" href="#L2073">2073</a><a id="L2074" href="#L2074">2074</a><a id="L2075" href="#L2075">2075</a><a id="L2076" href="#L2076">2076</a><a id="L2077" href="#L2077">2077</a><a id="L2078" href="#L2078">2078</a><a id="L2079" href="#L2079">2079</a><a id="L2080" href="#L2080">2080</a><a id="L2081" href="#L2081">2081</a><a id="L2082" href="#L2082">2082</a><a id="L2083" href="#L2083">2083</a><a id="L2084" href="#L2084">2084</a><a id="L2085" href="#L2085">2085</a><a id="L2086" href="#L2086">2086</a><a id="L2087" href="#L2087">2087</a><a id="L2088" href="#L2088">2088</a><a id="L2089" href="#L2089">2089</a><a id="L2090" href="#L2090">2090</a><a id="L2091" href="#L2091">2091</a><a id="L2092" href="#L2092">2092</a><a id="L2093" href="#L2093">2093</a><a id="L2094" href="#L2094">2094</a><a id="L2095" href="#L2095">2095</a><a id="L2096" href="#L2096">2096</a><a id="L2097" href="#L2097">2097</a><a id="L2098" href="#L2098">2098</a><a id="L2099" href="#L2099">2099</a><a id="L2100" href="#L2100">2100</a><a id="L2101" href="#L2101">2101</a><a id="L2102" href="#L2102">2102</a><a id="L2103" href="#L2103">2103</a><a id="L2104" href="#L2104">2104</a><a id="L2105" href="#L2105">2105</a><a id="L2106" href="#L2106">2106</a><a id="L2107" href="#L2107">2107</a><a id="L2108" href="#L2108">2108</a><a id="L2109" href="#L2109">2109</a><a id="L2110" href="#L2110">2110</a><a id="L2111" href="#L2111">2111</a><a id="L2112" href="#L2112">2112</a><a id="L2113" href="#L2113">2113</a><a id="L2114" href="#L2114">2114</a><a id="L2115" href="#L2115">2115</a><a id="L2116" href="#L2116">2116</a><a id="L2117" href="#L2117">2117</a><a id="L2118" href="#L2118">2118</a><a id="L2119" href="#L2119">2119</a><a id="L2120" href="#L2120">2120</a><a id="L2121" href="#L2121">2121</a><a id="L2122" href="#L2122">2122</a><a id="L2123" href="#L2123">2123</a><a id="L2124" href="#L2124">2124</a><a id="L2125" href="#L2125">2125</a><a id="L2126" href="#L2126">2126</a><a id="L2127" href="#L2127">2127</a><a id="L2128" href="#L2128">2128</a><a id="L2129" href="#L2129">2129</a><a id="L2130" href="#L2130">2130</a><a id="L2131" href="#L2131">2131</a><a id="L2132" href="#L2132">2132</a><a id="L2133" href="#L2133">2133</a><a id="L2134" href="#L2134">2134</a><a id="L2135" href="#L2135">2135</a><a id="L2136" href="#L2136">2136</a><a id="L2137" href="#L2137">2137</a><a id="L2138" href="#L2138">2138</a><a id="L2139" href="#L2139">2139</a><a id="L2140" href="#L2140">2140</a><a id="L2141" href="#L2141">2141</a><a id="L2142" href="#L2142">2142</a><a id="L2143" href="#L2143">2143</a><a id="L2144" href="#L2144">2144</a><a id="L2145" href="#L2145">2145</a><a id="L2146" href="#L2146">2146</a><a id="L2147" href="#L2147">2147</a><a id="L2148" href="#L2148">2148</a><a id="L2149" href="#L2149">2149</a><a id="L2150" href="#L2150">2150</a><a id="L2151" href="#L2151">2151</a><a id="L2152" href="#L2152">2152</a><a id="L2153" href="#L2153">2153</a><a id="L2154" href="#L2154">2154</a><a id="L2155" href="#L2155">2155</a><a id="L2156" href="#L2156">2156</a><a id="L2157" href="#L2157">2157</a><a id="L2158" href="#L2158">2158</a><a id="L2159" href="#L2159">2159</a><a id="L2160" href="#L2160">2160</a><a id="L2161" href="#L2161">2161</a><a id="L2162" href="#L2162">2162</a><a id="L2163" href="#L2163">2163</a><a id="L2164" href="#L2164">2164</a><a id="L2165" href="#L2165">2165</a><a id="L2166" href="#L2166">2166</a><a id="L2167" href="#L2167">2167</a><a id="L2168" href="#L2168">2168</a><a id="L2169" href="#L2169">2169</a><a id="L2170" href="#L2170">2170</a><a id="L2171" href="#L2171">2171</a><a id="L2172" href="#L2172">2172</a><a id="L2173" href="#L2173">2173</a><a id="L2174" href="#L2174">2174</a><a id="L2175" href="#L2175">2175</a><a id="L2176" href="#L2176">2176</a><a id="L2177" href="#L2177">2177</a><a id="L2178" href="#L2178">2178</a><a id="L2179" href="#L2179">2179</a><a id="L2180" href="#L2180">2180</a><a id="L2181" href="#L2181">2181</a><a id="L2182" href="#L2182">2182</a><a id="L2183" href="#L2183">2183</a><a id="L2184" href="#L2184">2184</a><a id="L2185" href="#L2185">2185</a><a id="L2186" href="#L2186">2186</a><a id="L2187" href="#L2187">2187</a><a id="L2188" href="#L2188">2188</a><a id="L2189" href="#L2189">2189</a><a id="L2190" href="#L2190">2190</a><a id="L2191" href="#L2191">2191</a><a id="L2192" href="#L2192">2192</a><a id="L2193" href="#L2193">2193</a><a id="L2194" href="#L2194">2194</a><a id="L2195" href="#L2195">2195</a><a id="L2196" href="#L2196">2196</a><a id="L2197" href="#L2197">2197</a><a id="L2198" href="#L2198">2198</a><a id="L2199" href="#L2199">2199</a><a id="L2200" href="#L2200">2200</a><a id="L2201" href="#L2201">2201</a><a id="L2202" href="#L2202">2202</a><a id="L2203" href="#L2203">2203</a><a id="L2204" href="#L2204">2204</a><a id="L2205" href="#L2205">2205</a><a id="L2206" href="#L2206">2206</a><a id="L2207" href="#L2207">2207</a><a id="L2208" href="#L2208">2208</a><a id="L2209" href="#L2209">2209</a><a id="L2210" href="#L2210">2210</a><a id="L2211" href="#L2211">2211</a><a id="L2212" href="#L2212">2212</a><a id="L2213" href="#L2213">2213</a><a id="L2214" href="#L2214">2214</a><a id="L2215" href="#L2215">2215</a><a id="L2216" href="#L2216">2216</a><a id="L2217" href="#L2217">2217</a><a id="L2218" href="#L2218">2218</a><a id="L2219" href="#L2219">2219</a><a id="L2220" href="#L2220">2220</a><a id="L2221" href="#L2221">2221</a><a id="L2222" href="#L2222">2222</a><a id="L2223" href="#L2223">2223</a><a id="L2224" href="#L2224">2224</a><a id="L2225" href="#L2225">2225</a><a id="L2226" href="#L2226">2226</a><a id="L2227" href="#L2227">2227</a><a id="L2228" href="#L2228">2228</a><a id="L2229" href="#L2229">2229</a><a id="L2230" href="#L2230">2230</a><a id="L2231" href="#L2231">2231</a><a id="L2232" href="#L2232">2232</a><a id="L2233" href="#L2233">2233</a><a id="L2234" href="#L2234">2234</a><a id="L2235" href="#L2235">2235</a><a id="L2236" href="#L2236">2236</a><a id="L2237" href="#L2237">2237</a><a id="L2238" href="#L2238">2238</a><a id="L2239" href="#L2239">2239</a><a id="L2240" href="#L2240">2240</a><a id="L2241" href="#L2241">2241</a><a id="L2242" href="#L2242">2242</a><a id="L2243" href="#L2243">2243</a><a id="L2244" href="#L2244">2244</a><a id="L2245" href="#L2245">2245</a><a id="L2246" href="#L2246">2246</a><a id="L2247" href="#L2247">2247</a><a id="L2248" href="#L2248">2248</a><a id="L2249" href="#L2249">2249</a><a id="L2250" href="#L2250">2250</a><a id="L2251" href="#L2251">2251</a><a id="L2252" href="#L2252">2252</a><a id="L2253" href="#L2253">2253</a><a id="L2254" href="#L2254">2254</a><a id="L2255" href="#L2255">2255</a><a id="L2256" href="#L2256">2256</a><a id="L2257" href="#L2257">2257</a><a id="L2258" href="#L2258">2258</a><a id="L2259" href="#L2259">2259</a><a id="L2260" href="#L2260">2260</a><a id="L2261" href="#L2261">2261</a><a id="L2262" href="#L2262">2262</a><a id="L2263" href="#L2263">2263</a><a id="L2264" href="#L2264">2264</a><a id="L2265" href="#L2265">2265</a><a id="L2266" href="#L2266">2266</a><a id="L2267" href="#L2267">2267</a><a id="L2268" href="#L2268">2268</a><a id="L2269" href="#L2269">2269</a><a id="L2270" href="#L2270">2270</a><a id="L2271" href="#L2271">2271</a><a id="L2272" href="#L2272">2272</a><a id="L2273" href="#L2273">2273</a><a id="L2274" href="#L2274">2274</a><a id="L2275" href="#L2275">2275</a><a id="L2276" href="#L2276">2276</a><a id="L2277" href="#L2277">2277</a><a id="L2278" href="#L2278">2278</a><a id="L2279" href="#L2279">2279</a><a id="L2280" href="#L2280">2280</a><a id="L2281" href="#L2281">2281</a><a id="L2282" href="#L2282">2282</a><a id="L2283" href="#L2283">2283</a><a id="L2284" href="#L2284">2284</a><a id="L2285" href="#L2285">2285</a><a id="L2286" href="#L2286">2286</a><a id="L2287" href="#L2287">2287</a><a id="L2288" href="#L2288">2288</a><a id="L2289" href="#L2289">2289</a><a id="L2290" href="#L2290">2290</a><a id="L2291" href="#L2291">2291</a><a id="L2292" href="#L2292">2292</a><a id="L2293" href="#L2293">2293</a><a id="L2294" href="#L2294">2294</a><a id="L2295" href="#L2295">2295</a><a id="L2296" href="#L2296">2296</a><a id="L2297" href="#L2297">2297</a><a id="L2298" href="#L2298">2298</a><a id="L2299" href="#L2299">2299</a><a id="L2300" href="#L2300">2300</a><a id="L2301" href="#L2301">2301</a><a id="L2302" href="#L2302">2302</a><a id="L2303" href="#L2303">2303</a><a id="L2304" href="#L2304">2304</a><a id="L2305" href="#L2305">2305</a><a id="L2306" href="#L2306">2306</a><a id="L2307" href="#L2307">2307</a><a id="L2308" href="#L2308">2308</a><a id="L2309" href="#L2309">2309</a><a id="L2310" href="#L2310">2310</a><a id="L2311" href="#L2311">2311</a><a id="L2312" href="#L2312">2312</a><a id="L2313" href="#L2313">2313</a><a id="L2314" href="#L2314">2314</a><a id="L2315" href="#L2315">2315</a><a id="L2316" href="#L2316">2316</a><a id="L2317" href="#L2317">2317</a><a id="L2318" href="#L2318">2318</a><a id="L2319" href="#L2319">2319</a><a id="L2320" href="#L2320">2320</a><a id="L2321" href="#L2321">2321</a><a id="L2322" href="#L2322">2322</a><a id="L2323" href="#L2323">2323</a><a id="L2324" href="#L2324">2324</a><a id="L2325" href="#L2325">2325</a><a id="L2326" href="#L2326">2326</a><a id="L2327" href="#L2327">2327</a><a id="L2328" href="#L2328">2328</a><a id="L2329" href="#L2329">2329</a><a id="L2330" href="#L2330">2330</a><a id="L2331" href="#L2331">2331</a><a id="L2332" href="#L2332">2332</a><a id="L2333" href="#L2333">2333</a><a id="L2334" href="#L2334">2334</a><a id="L2335" href="#L2335">2335</a><a id="L2336" href="#L2336">2336</a><a id="L2337" href="#L2337">2337</a><a id="L2338" href="#L2338">2338</a><a id="L2339" href="#L2339">2339</a><a id="L2340" href="#L2340">2340</a><a id="L2341" href="#L2341">2341</a><a id="L2342" href="#L2342">2342</a><a id="L2343" href="#L2343">2343</a><a id="L2344" href="#L2344">2344</a><a id="L2345" href="#L2345">2345</a><a id="L2346" href="#L2346">2346</a><a id="L2347" href="#L2347">2347</a><a id="L2348" href="#L2348">2348</a><a id="L2349" href="#L2349">2349</a><a id="L2350" href="#L2350">2350</a><a id="L2351" href="#L2351">2351</a><a id="L2352" href="#L2352">2352</a><a id="L2353" href="#L2353">2353</a><a id="L2354" href="#L2354">2354</a><a id="L2355" href="#L2355">2355</a><a id="L2356" href="#L2356">2356</a><a id="L2357" href="#L2357">2357</a><a id="L2358" href="#L2358">2358</a><a id="L2359" href="#L2359">2359</a><a id="L2360" href="#L2360">2360</a><a id="L2361" href="#L2361">2361</a><a id="L2362" href="#L2362">2362</a><a id="L2363" href="#L2363">2363</a><a id="L2364" href="#L2364">2364</a><a id="L2365" href="#L2365">2365</a><a id="L2366" href="#L2366">2366</a><a id="L2367" href="#L2367">2367</a><a id="L2368" href="#L2368">2368</a><a id="L2369" href="#L2369">2369</a><a id="L2370" href="#L2370">2370</a><a id="L2371" href="#L2371">2371</a><a id="L2372" href="#L2372">2372</a><a id="L2373" href="#L2373">2373</a><a id="L2374" href="#L2374">2374</a><a id="L2375" href="#L2375">2375</a><a id="L2376" href="#L2376">2376</a><a id="L2377" href="#L2377">2377</a><a id="L2378" href="#L2378">2378</a><a id="L2379" href="#L2379">2379</a><a id="L2380" href="#L2380">2380</a><a id="L2381" href="#L2381">2381</a><a id="L2382" href="#L2382">2382</a><a id="L2383" href="#L2383">2383</a><a id="L2384" href="#L2384">2384</a><a id="L2385" href="#L2385">2385</a><a id="L2386" href="#L2386">2386</a><a id="L2387" href="#L2387">2387</a><a id="L2388" href="#L2388">2388</a><a id="L2389" href="#L2389">2389</a><a id="L2390" href="#L2390">2390</a><a id="L2391" href="#L2391">2391</a><a id="L2392" href="#L2392">2392</a><a id="L2393" href="#L2393">2393</a><a id="L2394" href="#L2394">2394</a><a id="L2395" href="#L2395">2395</a><a id="L2396" href="#L2396">2396</a><a id="L2397" href="#L2397">2397</a><a id="L2398" href="#L2398">2398</a><a id="L2399" href="#L2399">2399</a><a id="L2400" href="#L2400">2400</a><a id="L2401" href="#L2401">2401</a><a id="L2402" href="#L2402">2402</a><a id="L2403" href="#L2403">2403</a><a id="L2404" href="#L2404">2404</a><a id="L2405" href="#L2405">2405</a><a id="L2406" href="#L2406">2406</a><a id="L2407" href="#L2407">2407</a><a id="L2408" href="#L2408">2408</a><a id="L2409" href="#L2409">2409</a><a id="L2410" href="#L2410">2410</a><a id="L2411" href="#L2411">2411</a><a id="L2412" href="#L2412">2412</a><a id="L2413" href="#L2413">2413</a><a id="L2414" href="#L2414">2414</a><a id="L2415" href="#L2415">2415</a><a id="L2416" href="#L2416">2416</a><a id="L2417" href="#L2417">2417</a><a id="L2418" href="#L2418">2418</a><a id="L2419" href="#L2419">2419</a><a id="L2420" href="#L2420">2420</a><a id="L2421" href="#L2421">2421</a><a id="L2422" href="#L2422">2422</a><a id="L2423" href="#L2423">2423</a><a id="L2424" href="#L2424">2424</a><a id="L2425" href="#L2425">2425</a><a id="L2426" href="#L2426">2426</a><a id="L2427" href="#L2427">2427</a><a id="L2428" href="#L2428">2428</a><a id="L2429" href="#L2429">2429</a><a id="L2430" href="#L2430">2430</a><a id="L2431" href="#L2431">2431</a><a id="L2432" href="#L2432">2432</a><a id="L2433" href="#L2433">2433</a><a id="L2434" href="#L2434">2434</a><a id="L2435" href="#L2435">2435</a><a id="L2436" href="#L2436">2436</a><a id="L2437" href="#L2437">2437</a><a id="L2438" href="#L2438">2438</a><a id="L2439" href="#L2439">2439</a><a id="L2440" href="#L2440">2440</a><a id="L2441" href="#L2441">2441</a><a id="L2442" href="#L2442">2442</a><a id="L2443" href="#L2443">2443</a><a id="L2444" href="#L2444">2444</a><a id="L2445" href="#L2445">2445</a><a id="L2446" href="#L2446">2446</a><a id="L2447" href="#L2447">2447</a><a id="L2448" href="#L2448">2448</a><a id="L2449" href="#L2449">2449</a><a id="L2450" href="#L2450">2450</a><a id="L2451" href="#L2451">2451</a><a id="L2452" href="#L2452">2452</a><a id="L2453" href="#L2453">2453</a><a id="L2454" href="#L2454">2454</a><a id="L2455" href="#L2455">2455</a><a id="L2456" href="#L2456">2456</a><a id="L2457" href="#L2457">2457</a><a id="L2458" href="#L2458">2458</a><a id="L2459" href="#L2459">2459</a><a id="L2460" href="#L2460">2460</a><a id="L2461" href="#L2461">2461</a><a id="L2462" href="#L2462">2462</a><a id="L2463" href="#L2463">2463</a><a id="L2464" href="#L2464">2464</a><a id="L2465" href="#L2465">2465</a><a id="L2466" href="#L2466">2466</a><a id="L2467" href="#L2467">2467</a><a id="L2468" href="#L2468">2468</a><a id="L2469" href="#L2469">2469</a><a id="L2470" href="#L2470">2470</a><a id="L2471" href="#L2471">2471</a><a id="L2472" href="#L2472">2472</a><a id="L2473" href="#L2473">2473</a><a id="L2474" href="#L2474">2474</a><a id="L2475" href="#L2475">2475</a><a id="L2476" href="#L2476">2476</a><a id="L2477" href="#L2477">2477</a><a id="L2478" href="#L2478">2478</a><a id="L2479" href="#L2479">2479</a><a id="L2480" href="#L2480">2480</a><a id="L2481" href="#L2481">2481</a><a id="L2482" href="#L2482">2482</a><a id="L2483" href="#L2483">2483</a><a id="L2484" href="#L2484">2484</a><a id="L2485" href="#L2485">2485</a><a id="L2486" href="#L2486">2486</a><a id="L2487" href="#L2487">2487</a><a id="L2488" href="#L2488">2488</a><a id="L2489" href="#L2489">2489</a><a id="L2490" href="#L2490">2490</a><a id="L2491" href="#L2491">2491</a><a id="L2492" href="#L2492">2492</a><a id="L2493" href="#L2493">2493</a><a id="L2494" href="#L2494">2494</a><a id="L2495" href="#L2495">2495</a><a id="L2496" href="#L2496">2496</a><a id="L2497" href="#L2497">2497</a><a id="L2498" href="#L2498">2498</a><a id="L2499" href="#L2499">2499</a><a id="L2500" href="#L2500">2500</a><a id="L2501" href="#L2501">2501</a><a id="L2502" href="#L2502">2502</a><a id="L2503" href="#L2503">2503</a><a id="L2504" href="#L2504">2504</a><a id="L2505" href="#L2505">2505</a><a id="L2506" href="#L2506">2506</a><a id="L2507" href="#L2507">2507</a><a id="L2508" href="#L2508">2508</a><a id="L2509" href="#L2509">2509</a><a id="L2510" href="#L2510">2510</a><a id="L2511" href="#L2511">2511</a><a id="L2512" href="#L2512">2512</a><a id="L2513" href="#L2513">2513</a><a id="L2514" href="#L2514">2514</a><a id="L2515" href="#L2515">2515</a><a id="L2516" href="#L2516">2516</a><a id="L2517" href="#L2517">2517</a><a id="L2518" href="#L2518">2518</a><a id="L2519" href="#L2519">2519</a><a id="L2520" href="#L2520">2520</a><a id="L2521" href="#L2521">2521</a><a id="L2522" href="#L2522">2522</a><a id="L2523" href="#L2523">2523</a><a id="L2524" href="#L2524">2524</a><a id="L2525" href="#L2525">2525</a><a id="L2526" href="#L2526">2526</a><a id="L2527" href="#L2527">2527</a><a id="L2528" href="#L2528">2528</a><a id="L2529" href="#L2529">2529</a><a id="L2530" href="#L2530">2530</a><a id="L2531" href="#L2531">2531</a><a id="L2532" href="#L2532">2532</a><a id="L2533" href="#L2533">2533</a><a id="L2534" href="#L2534">2534</a><a id="L2535" href="#L2535">2535</a><a id="L2536" href="#L2536">2536</a><a id="L2537" href="#L2537">2537</a><a id="L2538" href="#L2538">2538</a><a id="L2539" href="#L2539">2539</a><a id="L2540" href="#L2540">2540</a><a id="L2541" href="#L2541">2541</a><a id="L2542" href="#L2542">2542</a><a id="L2543" href="#L2543">2543</a><a id="L2544" href="#L2544">2544</a><a id="L2545" href="#L2545">2545</a><a id="L2546" href="#L2546">2546</a><a id="L2547" href="#L2547">2547</a><a id="L2548" href="#L2548">2548</a><a id="L2549" href="#L2549">2549</a><a id="L2550" href="#L2550">2550</a><a id="L2551" href="#L2551">2551</a><a id="L2552" href="#L2552">2552</a><a id="L2553" href="#L2553">2553</a><a id="L2554" href="#L2554">2554</a><a id="L2555" href="#L2555">2555</a><a id="L2556" href="#L2556">2556</a><a id="L2557" href="#L2557">2557</a><a id="L2558" href="#L2558">2558</a><a id="L2559" href="#L2559">2559</a><a id="L2560" href="#L2560">2560</a><a id="L2561" href="#L2561">2561</a><a id="L2562" href="#L2562">2562</a><a id="L2563" href="#L2563">2563</a><a id="L2564" href="#L2564">2564</a><a id="L2565" href="#L2565">2565</a><a id="L2566" href="#L2566">2566</a><a id="L2567" href="#L2567">2567</a><a id="L2568" href="#L2568">2568</a><a id="L2569" href="#L2569">2569</a><a id="L2570" href="#L2570">2570</a><a id="L2571" href="#L2571">2571</a><a id="L2572" href="#L2572">2572</a><a id="L2573" href="#L2573">2573</a><a id="L2574" href="#L2574">2574</a><a id="L2575" href="#L2575">2575</a><a id="L2576" href="#L2576">2576</a><a id="L2577" href="#L2577">2577</a><a id="L2578" href="#L2578">2578</a><a id="L2579" href="#L2579">2579</a><a id="L2580" href="#L2580">2580</a><a id="L2581" href="#L2581">2581</a><a id="L2582" href="#L2582">2582</a><a id="L2583" href="#L2583">2583</a><a id="L2584" href="#L2584">2584</a><a id="L2585" href="#L2585">2585</a><a id="L2586" href="#L2586">2586</a><a id="L2587" href="#L2587">2587</a><a id="L2588" href="#L2588">2588</a><a id="L2589" href="#L2589">2589</a><a id="L2590" href="#L2590">2590</a><a id="L2591" href="#L2591">2591</a><a id="L2592" href="#L2592">2592</a><a id="L2593" href="#L2593">2593</a><a id="L2594" href="#L2594">2594</a><a id="L2595" href="#L2595">2595</a><a id="L2596" href="#L2596">2596</a><a id="L2597" href="#L2597">2597</a><a id="L2598" href="#L2598">2598</a><a id="L2599" href="#L2599">2599</a><a id="L2600" href="#L2600">2600</a><a id="L2601" href="#L2601">2601</a><a id="L2602" href="#L2602">2602</a><a id="L2603" href="#L2603">2603</a><a id="L2604" href="#L2604">2604</a><a id="L2605" href="#L2605">2605</a><a id="L2606" href="#L2606">2606</a><a id="L2607" href="#L2607">2607</a><a id="L2608" href="#L2608">2608</a><a id="L2609" href="#L2609">2609</a><a id="L2610" href="#L2610">2610</a><a id="L2611" href="#L2611">2611</a><a id="L2612" href="#L2612">2612</a><a id="L2613" href="#L2613">2613</a><a id="L2614" href="#L2614">2614</a><a id="L2615" href="#L2615">2615</a><a id="L2616" href="#L2616">2616</a><a id="L2617" href="#L2617">2617</a><a id="L2618" href="#L2618">2618</a><a id="L2619" href="#L2619">2619</a><a id="L2620" href="#L2620">2620</a><a id="L2621" href="#L2621">2621</a><a id="L2622" href="#L2622">2622</a><a id="L2623" href="#L2623">2623</a><a id="L2624" href="#L2624">2624</a><a id="L2625" href="#L2625">2625</a><a id="L2626" href="#L2626">2626</a><a id="L2627" href="#L2627">2627</a><a id="L2628" href="#L2628">2628</a><a id="L2629" href="#L2629">2629</a><a id="L2630" href="#L2630">2630</a><a id="L2631" href="#L2631">2631</a><a id="L2632" href="#L2632">2632</a><a id="L2633" href="#L2633">2633</a><a id="L2634" href="#L2634">2634</a><a id="L2635" href="#L2635">2635</a><a id="L2636" href="#L2636">2636</a><a id="L2637" href="#L2637">2637</a><a id="L2638" href="#L2638">2638</a><a id="L2639" href="#L2639">2639</a><a id="L2640" href="#L2640">2640</a><a id="L2641" href="#L2641">2641</a><a id="L2642" href="#L2642">2642</a><a id="L2643" href="#L2643">2643</a><a id="L2644" href="#L2644">2644</a><a id="L2645" href="#L2645">2645</a><a id="L2646" href="#L2646">2646</a><a id="L2647" href="#L2647">2647</a><a id="L2648" href="#L2648">2648</a><a id="L2649" href="#L2649">2649</a><a id="L2650" href="#L2650">2650</a><a id="L2651" href="#L2651">2651</a><a id="L2652" href="#L2652">2652</a><a id="L2653" href="#L2653">2653</a><a id="L2654" href="#L2654">2654</a><a id="L2655" href="#L2655">2655</a><a id="L2656" href="#L2656">2656</a><a id="L2657" href="#L2657">2657</a><a id="L2658" href="#L2658">2658</a><a id="L2659" href="#L2659">2659</a><a id="L2660" href="#L2660">2660</a><a id="L2661" href="#L2661">2661</a><a id="L2662" href="#L2662">2662</a><a id="L2663" href="#L2663">2663</a><a id="L2664" href="#L2664">2664</a><a id="L2665" href="#L2665">2665</a><a id="L2666" href="#L2666">2666</a><a id="L2667" href="#L2667">2667</a><a id="L2668" href="#L2668">2668</a><a id="L2669" href="#L2669">2669</a><a id="L2670" href="#L2670">2670</a><a id="L2671" href="#L2671">2671</a><a id="L2672" href="#L2672">2672</a><a id="L2673" href="#L2673">2673</a><a id="L2674" href="#L2674">2674</a><a id="L2675" href="#L2675">2675</a><a id="L2676" href="#L2676">2676</a><a id="L2677" href="#L2677">2677</a><a id="L2678" href="#L2678">2678</a><a id="L2679" href="#L2679">2679</a><a id="L2680" href="#L2680">2680</a><a id="L2681" href="#L2681">2681</a><a id="L2682" href="#L2682">2682</a><a id="L2683" href="#L2683">2683</a><a id="L2684" href="#L2684">2684</a><a id="L2685" href="#L2685">2685</a><a id="L2686" href="#L2686">2686</a><a id="L2687" href="#L2687">2687</a><a id="L2688" href="#L2688">2688</a><a id="L2689" href="#L2689">2689</a><a id="L2690" href="#L2690">2690</a><a id="L2691" href="#L2691">2691</a><a id="L2692" href="#L2692">2692</a><a id="L2693" href="#L2693">2693</a><a id="L2694" href="#L2694">2694</a><a id="L2695" href="#L2695">2695</a><a id="L2696" href="#L2696">2696</a><a id="L2697" href="#L2697">2697</a><a id="L2698" href="#L2698">2698</a><a id="L2699" href="#L2699">2699</a><a id="L2700" href="#L2700">2700</a><a id="L2701" href="#L2701">2701</a><a id="L2702" href="#L2702">2702</a><a id="L2703" href="#L2703">2703</a><a id="L2704" href="#L2704">2704</a><a id="L2705" href="#L2705">2705</a><a id="L2706" href="#L2706">2706</a><a id="L2707" href="#L2707">2707</a><a id="L2708" href="#L2708">2708</a><a id="L2709" href="#L2709">2709</a><a id="L2710" href="#L2710">2710</a><a id="L2711" href="#L2711">2711</a><a id="L2712" href="#L2712">2712</a><a id="L2713" href="#L2713">2713</a><a id="L2714" href="#L2714">2714</a><a id="L2715" href="#L2715">2715</a><a id="L2716" href="#L2716">2716</a><a id="L2717" href="#L2717">2717</a><a id="L2718" href="#L2718">2718</a><a id="L2719" href="#L2719">2719</a><a id="L2720" href="#L2720">2720</a><a id="L2721" href="#L2721">2721</a><a id="L2722" href="#L2722">2722</a><a id="L2723" href="#L2723">2723</a><a id="L2724" href="#L2724">2724</a><a id="L2725" href="#L2725">2725</a><a id="L2726" href="#L2726">2726</a><a id="L2727" href="#L2727">2727</a><a id="L2728" href="#L2728">2728</a><a id="L2729" href="#L2729">2729</a><a id="L2730" href="#L2730">2730</a><a id="L2731" href="#L2731">2731</a><a id="L2732" href="#L2732">2732</a><a id="L2733" href="#L2733">2733</a><a id="L2734" href="#L2734">2734</a><a id="L2735" href="#L2735">2735</a><a id="L2736" href="#L2736">2736</a><a id="L2737" href="#L2737">2737</a><a id="L2738" href="#L2738">2738</a><a id="L2739" href="#L2739">2739</a><a id="L2740" href="#L2740">2740</a><a id="L2741" href="#L2741">2741</a><a id="L2742" href="#L2742">2742</a><a id="L2743" href="#L2743">2743</a><a id="L2744" href="#L2744">2744</a><a id="L2745" href="#L2745">2745</a><a id="L2746" href="#L2746">2746</a><a id="L2747" href="#L2747">2747</a><a id="L2748" href="#L2748">2748</a><a id="L2749" href="#L2749">2749</a><a id="L2750" href="#L2750">2750</a><a id="L2751" href="#L2751">2751</a><a id="L2752" href="#L2752">2752</a><a id="L2753" href="#L2753">2753</a><a id="L2754" href="#L2754">2754</a><a id="L2755" href="#L2755">2755</a><a id="L2756" href="#L2756">2756</a><a id="L2757" href="#L2757">2757</a><a id="L2758" href="#L2758">2758</a><a id="L2759" href="#L2759">2759</a><a id="L2760" href="#L2760">2760</a><a id="L2761" href="#L2761">2761</a><a id="L2762" href="#L2762">2762</a><a id="L2763" href="#L2763">2763</a><a id="L2764" href="#L2764">2764</a><a id="L2765" href="#L2765">2765</a><a id="L2766" href="#L2766">2766</a><a id="L2767" href="#L2767">2767</a><a id="L2768" href="#L2768">2768</a><a id="L2769" href="#L2769">2769</a><a id="L2770" href="#L2770">2770</a><a id="L2771" href="#L2771">2771</a><a id="L2772" href="#L2772">2772</a><a id="L2773" href="#L2773">2773</a><a id="L2774" href="#L2774">2774</a><a id="L2775" href="#L2775">2775</a><a id="L2776" href="#L2776">2776</a><a id="L2777" href="#L2777">2777</a><a id="L2778" href="#L2778">2778</a><a id="L2779" href="#L2779">2779</a><a id="L2780" href="#L2780">2780</a><a id="L2781" href="#L2781">2781</a><a id="L2782" href="#L2782">2782</a><a id="L2783" href="#L2783">2783</a><a id="L2784" href="#L2784">2784</a><a id="L2785" href="#L2785">2785</a><a id="L2786" href="#L2786">2786</a><a id="L2787" href="#L2787">2787</a><a id="L2788" href="#L2788">2788</a><a id="L2789" href="#L2789">2789</a><a id="L2790" href="#L2790">2790</a><a id="L2791" href="#L2791">2791</a><a id="L2792" href="#L2792">2792</a><a id="L2793" href="#L2793">2793</a><a id="L2794" href="#L2794">2794</a><a id="L2795" href="#L2795">2795</a><a id="L2796" href="#L2796">2796</a><a id="L2797" href="#L2797">2797</a><a id="L2798" href="#L2798">2798</a><a id="L2799" href="#L2799">2799</a><a id="L2800" href="#L2800">2800</a><a id="L2801" href="#L2801">2801</a><a id="L2802" href="#L2802">2802</a><a id="L2803" href="#L2803">2803</a><a id="L2804" href="#L2804">2804</a><a id="L2805" href="#L2805">2805</a><a id="L2806" href="#L2806">2806</a><a id="L2807" href="#L2807">2807</a><a id="L2808" href="#L2808">2808</a><a id="L2809" href="#L2809">2809</a><a id="L2810" href="#L2810">2810</a><a id="L2811" href="#L2811">2811</a><a id="L2812" href="#L2812">2812</a><a id="L2813" href="#L2813">2813</a><a id="L2814" href="#L2814">2814</a><a id="L2815" href="#L2815">2815</a><a id="L2816" href="#L2816">2816</a><a id="L2817" href="#L2817">2817</a><a id="L2818" href="#L2818">2818</a><a id="L2819" href="#L2819">2819</a><a id="L2820" href="#L2820">2820</a><a id="L2821" href="#L2821">2821</a><a id="L2822" href="#L2822">2822</a><a id="L2823" href="#L2823">2823</a><a id="L2824" href="#L2824">2824</a><a id="L2825" href="#L2825">2825</a><a id="L2826" href="#L2826">2826</a><a id="L2827" href="#L2827">2827</a><a id="L2828" href="#L2828">2828</a><a id="L2829" href="#L2829">2829</a><a id="L2830" href="#L2830">2830</a><a id="L2831" href="#L2831">2831</a><a id="L2832" href="#L2832">2832</a><a id="L2833" href="#L2833">2833</a><a id="L2834" href="#L2834">2834</a><a id="L2835" href="#L2835">2835</a><a id="L2836" href="#L2836">2836</a><a id="L2837" href="#L2837">2837</a><a id="L2838" href="#L2838">2838</a><a id="L2839" href="#L2839">2839</a><a id="L2840" href="#L2840">2840</a><a id="L2841" href="#L2841">2841</a><a id="L2842" href="#L2842">2842</a><a id="L2843" href="#L2843">2843</a><a id="L2844" href="#L2844">2844</a><a id="L2845" href="#L2845">2845</a><a id="L2846" href="#L2846">2846</a><a id="L2847" href="#L2847">2847</a><a id="L2848" href="#L2848">2848</a><a id="L2849" href="#L2849">2849</a><a id="L2850" href="#L2850">2850</a><a id="L2851" href="#L2851">2851</a><a id="L2852" href="#L2852">2852</a><a id="L2853" href="#L2853">2853</a><a id="L2854" href="#L2854">2854</a><a id="L2855" href="#L2855">2855</a><a id="L2856" href="#L2856">2856</a><a id="L2857" href="#L2857">2857</a><a id="L2858" href="#L2858">2858</a><a id="L2859" href="#L2859">2859</a><a id="L2860" href="#L2860">2860</a><a id="L2861" href="#L2861">2861</a><a id="L2862" href="#L2862">2862</a><a id="L2863" href="#L2863">2863</a><a id="L2864" href="#L2864">2864</a><a id="L2865" href="#L2865">2865</a><a id="L2866" href="#L2866">2866</a><a id="L2867" href="#L2867">2867</a><a id="L2868" href="#L2868">2868</a><a id="L2869" href="#L2869">2869</a><a id="L2870" href="#L2870">2870</a><a id="L2871" href="#L2871">2871</a><a id="L2872" href="#L2872">2872</a><a id="L2873" href="#L2873">2873</a><a id="L2874" href="#L2874">2874</a><a id="L2875" href="#L2875">2875</a><a id="L2876" href="#L2876">2876</a><a id="L2877" href="#L2877">2877</a><a id="L2878" href="#L2878">2878</a><a id="L2879" href="#L2879">2879</a><a id="L2880" href="#L2880">2880</a><a id="L2881" href="#L2881">2881</a><a id="L2882" href="#L2882">2882</a><a id="L2883" href="#L2883">2883</a><a id="L2884" href="#L2884">2884</a><a id="L2885" href="#L2885">2885</a><a id="L2886" href="#L2886">2886</a><a id="L2887" href="#L2887">2887</a><a id="L2888" href="#L2888">2888</a><a id="L2889" href="#L2889">2889</a><a id="L2890" href="#L2890">2890</a><a id="L2891" href="#L2891">2891</a><a id="L2892" href="#L2892">2892</a><a id="L2893" href="#L2893">2893</a><a id="L2894" href="#L2894">2894</a><a id="L2895" href="#L2895">2895</a><a id="L2896" href="#L2896">2896</a><a id="L2897" href="#L2897">2897</a><a id="L2898" href="#L2898">2898</a><a id="L2899" href="#L2899">2899</a><a id="L2900" href="#L2900">2900</a><a id="L2901" href="#L2901">2901</a><a id="L2902" href="#L2902">2902</a><a id="L2903" href="#L2903">2903</a><a id="L2904" href="#L2904">2904</a><a id="L2905" href="#L2905">2905</a><a id="L2906" href="#L2906">2906</a><a id="L2907" href="#L2907">2907</a><a id="L2908" href="#L2908">2908</a><a id="L2909" href="#L2909">2909</a><a id="L2910" href="#L2910">2910</a><a id="L2911" href="#L2911">2911</a><a id="L2912" href="#L2912">2912</a><a id="L2913" href="#L2913">2913</a><a id="L2914" href="#L2914">2914</a><a id="L2915" href="#L2915">2915</a><a id="L2916" href="#L2916">2916</a><a id="L2917" href="#L2917">2917</a><a id="L2918" href="#L2918">2918</a><a id="L2919" href="#L2919">2919</a><a id="L2920" href="#L2920">2920</a><a id="L2921" href="#L2921">2921</a><a id="L2922" href="#L2922">2922</a><a id="L2923" href="#L2923">2923</a><a id="L2924" href="#L2924">2924</a><a id="L2925" href="#L2925">2925</a><a id="L2926" href="#L2926">2926</a><a id="L2927" href="#L2927">2927</a><a id="L2928" href="#L2928">2928</a><a id="L2929" href="#L2929">2929</a><a id="L2930" href="#L2930">2930</a><a id="L2931" href="#L2931">2931</a><a id="L2932" href="#L2932">2932</a><a id="L2933" href="#L2933">2933</a><a id="L2934" href="#L2934">2934</a><a id="L2935" href="#L2935">2935</a><a id="L2936" href="#L2936">2936</a><a id="L2937" href="#L2937">2937</a><a id="L2938" href="#L2938">2938</a><a id="L2939" href="#L2939">2939</a><a id="L2940" href="#L2940">2940</a><a id="L2941" href="#L2941">2941</a><a id="L2942" href="#L2942">2942</a><a id="L2943" href="#L2943">2943</a><a id="L2944" href="#L2944">2944</a><a id="L2945" href="#L2945">2945</a><a id="L2946" href="#L2946">2946</a><a id="L2947" href="#L2947">2947</a><a id="L2948" href="#L2948">2948</a><a id="L2949" href="#L2949">2949</a><a id="L2950" href="#L2950">2950</a><a id="L2951" href="#L2951">2951</a><a id="L2952" href="#L2952">2952</a><a id="L2953" href="#L2953">2953</a><a id="L2954" href="#L2954">2954</a><a id="L2955" href="#L2955">2955</a><a id="L2956" href="#L2956">2956</a><a id="L2957" href="#L2957">2957</a><a id="L2958" href="#L2958">2958</a><a id="L2959" href="#L2959">2959</a><a id="L2960" href="#L2960">2960</a><a id="L2961" href="#L2961">2961</a><a id="L2962" href="#L2962">2962</a><a id="L2963" href="#L2963">2963</a><a id="L2964" href="#L2964">2964</a><a id="L2965" href="#L2965">2965</a><a id="L2966" href="#L2966">2966</a><a id="L2967" href="#L2967">2967</a><a id="L2968" href="#L2968">2968</a><a id="L2969" href="#L2969">2969</a><a id="L2970" href="#L2970">2970</a><a id="L2971" href="#L2971">2971</a><a id="L2972" href="#L2972">2972</a><a id="L2973" href="#L2973">2973</a><a id="L2974" href="#L2974">2974</a><a id="L2975" href="#L2975">2975</a><a id="L2976" href="#L2976">2976</a><a id="L2977" href="#L2977">2977</a><a id="L2978" href="#L2978">2978</a><a id="L2979" href="#L2979">2979</a><a id="L2980" href="#L2980">2980</a><a id="L2981" href="#L2981">2981</a><a id="L2982" href="#L2982">2982</a><a id="L2983" href="#L2983">2983</a><a id="L2984" href="#L2984">2984</a><a id="L2985" href="#L2985">2985</a><a id="L2986" href="#L2986">2986</a><a id="L2987" href="#L2987">2987</a><a id="L2988" href="#L2988">2988</a><a id="L2989" href="#L2989">2989</a><a id="L2990" href="#L2990">2990</a><a id="L2991" href="#L2991">2991</a><a id="L2992" href="#L2992">2992</a><a id="L2993" href="#L2993">2993</a><a id="L2994" href="#L2994">2994</a><a id="L2995" href="#L2995">2995</a><a id="L2996" href="#L2996">2996</a><a id="L2997" href="#L2997">2997</a><a id="L2998" href="#L2998">2998</a><a id="L2999" href="#L2999">2999</a><a id="L3000" href="#L3000">3000</a><a id="L3001" href="#L3001">3001</a><a id="L3002" href="#L3002">3002</a><a id="L3003" href="#L3003">3003</a><a id="L3004" href="#L3004">3004</a><a id="L3005" href="#L3005">3005</a><a id="L3006" href="#L3006">3006</a><a id="L3007" href="#L3007">3007</a><a id="L3008" href="#L3008">3008</a><a id="L3009" href="#L3009">3009</a><a id="L3010" href="#L3010">3010</a><a id="L3011" href="#L3011">3011</a><a id="L3012" href="#L3012">3012</a><a id="L3013" href="#L3013">3013</a><a id="L3014" href="#L3014">3014</a><a id="L3015" href="#L3015">3015</a><a id="L3016" href="#L3016">3016</a><a id="L3017" href="#L3017">3017</a><a id="L3018" href="#L3018">3018</a><a id="L3019" href="#L3019">3019</a><a id="L3020" href="#L3020">3020</a><a id="L3021" href="#L3021">3021</a><a id="L3022" href="#L3022">3022</a><a id="L3023" href="#L3023">3023</a><a id="L3024" href="#L3024">3024</a><a id="L3025" href="#L3025">3025</a><a id="L3026" href="#L3026">3026</a><a id="L3027" href="#L3027">3027</a><a id="L3028" href="#L3028">3028</a><a id="L3029" href="#L3029">3029</a><a id="L3030" href="#L3030">3030</a><a id="L3031" href="#L3031">3031</a><a id="L3032" href="#L3032">3032</a><a id="L3033" href="#L3033">3033</a><a id="L3034" href="#L3034">3034</a><a id="L3035" href="#L3035">3035</a><a id="L3036" href="#L3036">3036</a><a id="L3037" href="#L3037">3037</a><a id="L3038" href="#L3038">3038</a><a id="L3039" href="#L3039">3039</a><a id="L3040" href="#L3040">3040</a><a id="L3041" href="#L3041">3041</a><a id="L3042" href="#L3042">3042</a><a id="L3043" href="#L3043">3043</a><a id="L3044" href="#L3044">3044</a><a id="L3045" href="#L3045">3045</a><a id="L3046" href="#L3046">3046</a><a id="L3047" href="#L3047">3047</a><a id="L3048" href="#L3048">3048</a><a id="L3049" href="#L3049">3049</a><a id="L3050" href="#L3050">3050</a><a id="L3051" href="#L3051">3051</a><a id="L3052" href="#L3052">3052</a><a id="L3053" href="#L3053">3053</a><a id="L3054" href="#L3054">3054</a><a id="L3055" href="#L3055">3055</a><a id="L3056" href="#L3056">3056</a><a id="L3057" href="#L3057">3057</a><a id="L3058" href="#L3058">3058</a><a id="L3059" href="#L3059">3059</a><a id="L3060" href="#L3060">3060</a><a id="L3061" href="#L3061">3061</a><a id="L3062" href="#L3062">3062</a><a id="L3063" href="#L3063">3063</a><a id="L3064" href="#L3064">3064</a><a id="L3065" href="#L3065">3065</a><a id="L3066" href="#L3066">3066</a><a id="L3067" href="#L3067">3067</a><a id="L3068" href="#L3068">3068</a><a id="L3069" href="#L3069">3069</a><a id="L3070" href="#L3070">3070</a><a id="L3071" href="#L3071">3071</a><a id="L3072" href="#L3072">3072</a><a id="L3073" href="#L3073">3073</a><a id="L3074" href="#L3074">3074</a><a id="L3075" href="#L3075">3075</a><a id="L3076" href="#L3076">3076</a><a id="L3077" href="#L3077">3077</a><a id="L3078" href="#L3078">3078</a><a id="L3079" href="#L3079">3079</a><a id="L3080" href="#L3080">3080</a><a id="L3081" href="#L3081">3081</a><a id="L3082" href="#L3082">3082</a><a id="L3083" href="#L3083">3083</a><a id="L3084" href="#L3084">3084</a><a id="L3085" href="#L3085">3085</a><a id="L3086" href="#L3086">3086</a><a id="L3087" href="#L3087">3087</a><a id="L3088" href="#L3088">3088</a><a id="L3089" href="#L3089">3089</a><a id="L3090" href="#L3090">3090</a><a id="L3091" href="#L3091">3091</a><a id="L3092" href="#L3092">3092</a><a id="L3093" href="#L3093">3093</a><a id="L3094" href="#L3094">3094</a><a id="L3095" href="#L3095">3095</a><a id="L3096" href="#L3096">3096</a><a id="L3097" href="#L3097">3097</a><a id="L3098" href="#L3098">3098</a><a id="L3099" href="#L3099">3099</a><a id="L3100" href="#L3100">3100</a><a id="L3101" href="#L3101">3101</a><a id="L3102" href="#L3102">3102</a><a id="L3103" href="#L3103">3103</a><a id="L3104" href="#L3104">3104</a><a id="L3105" href="#L3105">3105</a><a id="L3106" href="#L3106">3106</a><a id="L3107" href="#L3107">3107</a><a id="L3108" href="#L3108">3108</a><a id="L3109" href="#L3109">3109</a><a id="L3110" href="#L3110">3110</a><a id="L3111" href="#L3111">3111</a><a id="L3112" href="#L3112">3112</a><a id="L3113" href="#L3113">3113</a><a id="L3114" href="#L3114">3114</a><a id="L3115" href="#L3115">3115</a><a id="L3116" href="#L3116">3116</a><a id="L3117" href="#L3117">3117</a><a id="L3118" href="#L3118">3118</a><a id="L3119" href="#L3119">3119</a><a id="L3120" href="#L3120">3120</a><a id="L3121" href="#L3121">3121</a><a id="L3122" href="#L3122">3122</a><a id="L3123" href="#L3123">3123</a><a id="L3124" href="#L3124">3124</a><a id="L3125" href="#L3125">3125</a><a id="L3126" href="#L3126">3126</a><a id="L3127" href="#L3127">3127</a><a id="L3128" href="#L3128">3128</a><a id="L3129" href="#L3129">3129</a><a id="L3130" href="#L3130">3130</a><a id="L3131" href="#L3131">3131</a><a id="L3132" href="#L3132">3132</a><a id="L3133" href="#L3133">3133</a><a id="L3134" href="#L3134">3134</a><a id="L3135" href="#L3135">3135</a><a id="L3136" href="#L3136">3136</a><a id="L3137" href="#L3137">3137</a><a id="L3138" href="#L3138">3138</a><a id="L3139" href="#L3139">3139</a><a id="L3140" href="#L3140">3140</a><a id="L3141" href="#L3141">3141</a><a id="L3142" href="#L3142">3142</a><a id="L3143" href="#L3143">3143</a><a id="L3144" href="#L3144">3144</a><a id="L3145" href="#L3145">3145</a><a id="L3146" href="#L3146">3146</a><a id="L3147" href="#L3147">3147</a><a id="L3148" href="#L3148">3148</a><a id="L3149" href="#L3149">3149</a><a id="L3150" href="#L3150">3150</a><a id="L3151" href="#L3151">3151</a><a id="L3152" href="#L3152">3152</a><a id="L3153" href="#L3153">3153</a><a id="L3154" href="#L3154">3154</a><a id="L3155" href="#L3155">3155</a><a id="L3156" href="#L3156">3156</a><a id="L3157" href="#L3157">3157</a><a id="L3158" href="#L3158">3158</a><a id="L3159" href="#L3159">3159</a><a id="L3160" href="#L3160">3160</a><a id="L3161" href="#L3161">3161</a><a id="L3162" href="#L3162">3162</a><a id="L3163" href="#L3163">3163</a><a id="L3164" href="#L3164">3164</a><a id="L3165" href="#L3165">3165</a><a id="L3166" href="#L3166">3166</a><a id="L3167" href="#L3167">3167</a><a id="L3168" href="#L3168">3168</a><a id="L3169" href="#L3169">3169</a><a id="L3170" href="#L3170">3170</a><a id="L3171" href="#L3171">3171</a><a id="L3172" href="#L3172">3172</a><a id="L3173" href="#L3173">3173</a><a id="L3174" href="#L3174">3174</a><a id="L3175" href="#L3175">3175</a><a id="L3176" href="#L3176">3176</a><a id="L3177" href="#L3177">3177</a><a id="L3178" href="#L3178">3178</a><a id="L3179" href="#L3179">3179</a><a id="L3180" href="#L3180">3180</a><a id="L3181" href="#L3181">3181</a><a id="L3182" href="#L3182">3182</a><a id="L3183" href="#L3183">3183</a><a id="L3184" href="#L3184">3184</a><a id="L3185" href="#L3185">3185</a><a id="L3186" href="#L3186">3186</a><a id="L3187" href="#L3187">3187</a><a id="L3188" href="#L3188">3188</a><a id="L3189" href="#L3189">3189</a><a id="L3190" href="#L3190">3190</a><a id="L3191" href="#L3191">3191</a><a id="L3192" href="#L3192">3192</a><a id="L3193" href="#L3193">3193</a><a id="L3194" href="#L3194">3194</a><a id="L3195" href="#L3195">3195</a><a id="L3196" href="#L3196">3196</a><a id="L3197" href="#L3197">3197</a><a id="L3198" href="#L3198">3198</a><a id="L3199" href="#L3199">3199</a><a id="L3200" href="#L3200">3200</a><a id="L3201" href="#L3201">3201</a><a id="L3202" href="#L3202">3202</a><a id="L3203" href="#L3203">3203</a><a id="L3204" href="#L3204">3204</a><a id="L3205" href="#L3205">3205</a><a id="L3206" href="#L3206">3206</a><a id="L3207" href="#L3207">3207</a><a id="L3208" href="#L3208">3208</a><a id="L3209" href="#L3209">3209</a><a id="L3210" href="#L3210">3210</a><a id="L3211" href="#L3211">3211</a><a id="L3212" href="#L3212">3212</a><a id="L3213" href="#L3213">3213</a><a id="L3214" href="#L3214">3214</a><a id="L3215" href="#L3215">3215</a><a id="L3216" href="#L3216">3216</a><a id="L3217" href="#L3217">3217</a><a id="L3218" href="#L3218">3218</a><a id="L3219" href="#L3219">3219</a><a id="L3220" href="#L3220">3220</a><a id="L3221" href="#L3221">3221</a><a id="L3222" href="#L3222">3222</a><a id="L3223" href="#L3223">3223</a><a id="L3224" href="#L3224">3224</a><a id="L3225" href="#L3225">3225</a><a id="L3226" href="#L3226">3226</a><a id="L3227" href="#L3227">3227</a><a id="L3228" href="#L3228">3228</a><a id="L3229" href="#L3229">3229</a><a id="L3230" href="#L3230">3230</a><a id="L3231" href="#L3231">3231</a><a id="L3232" href="#L3232">3232</a><a id="L3233" href="#L3233">3233</a><a id="L3234" href="#L3234">3234</a><a id="L3235" href="#L3235">3235</a><a id="L3236" href="#L3236">3236</a><a id="L3237" href="#L3237">3237</a><a id="L3238" href="#L3238">3238</a><a id="L3239" href="#L3239">3239</a><a id="L3240" href="#L3240">3240</a><a id="L3241" href="#L3241">3241</a><a id="L3242" href="#L3242">3242</a><a id="L3243" href="#L3243">3243</a><a id="L3244" href="#L3244">3244</a><a id="L3245" href="#L3245">3245</a><a id="L3246" href="#L3246">3246</a><a id="L3247" href="#L3247">3247</a><a id="L3248" href="#L3248">3248</a><a id="L3249" href="#L3249">3249</a><a id="L3250" href="#L3250">3250</a><a id="L3251" href="#L3251">3251</a><a id="L3252" href="#L3252">3252</a><a id="L3253" href="#L3253">3253</a><a id="L3254" href="#L3254">3254</a><a id="L3255" href="#L3255">3255</a><a id="L3256" href="#L3256">3256</a><a id="L3257" href="#L3257">3257</a><a id="L3258" href="#L3258">3258</a><a id="L3259" href="#L3259">3259</a><a id="L3260" href="#L3260">3260</a><a id="L3261" href="#L3261">3261</a><a id="L3262" href="#L3262">3262</a><a id="L3263" href="#L3263">3263</a><a id="L3264" href="#L3264">3264</a><a id="L3265" href="#L3265">3265</a><a id="L3266" href="#L3266">3266</a><a id="L3267" href="#L3267">3267</a><a id="L3268" href="#L3268">3268</a><a id="L3269" href="#L3269">3269</a><a id="L3270" href="#L3270">3270</a><a id="L3271" href="#L3271">3271</a><a id="L3272" href="#L3272">3272</a><a id="L3273" href="#L3273">3273</a><a id="L3274" href="#L3274">3274</a><a id="L3275" href="#L3275">3275</a><a id="L3276" href="#L3276">3276</a><a id="L3277" href="#L3277">3277</a><a id="L3278" href="#L3278">3278</a><a id="L3279" href="#L3279">3279</a><a id="L3280" href="#L3280">3280</a><a id="L3281" href="#L3281">3281</a><a id="L3282" href="#L3282">3282</a><a id="L3283" href="#L3283">3283</a><a id="L3284" href="#L3284">3284</a><a id="L3285" href="#L3285">3285</a><a id="L3286" href="#L3286">3286</a><a id="L3287" href="#L3287">3287</a><a id="L3288" href="#L3288">3288</a><a id="L3289" href="#L3289">3289</a><a id="L3290" href="#L3290">3290</a><a id="L3291" href="#L3291">3291</a><a id="L3292" href="#L3292">3292</a><a id="L3293" href="#L3293">3293</a><a id="L3294" href="#L3294">3294</a><a id="L3295" href="#L3295">3295</a><a id="L3296" href="#L3296">3296</a><a id="L3297" href="#L3297">3297</a><a id="L3298" href="#L3298">3298</a><a id="L3299" href="#L3299">3299</a><a id="L3300" href="#L3300">3300</a><a id="L3301" href="#L3301">3301</a><a id="L3302" href="#L3302">3302</a><a id="L3303" href="#L3303">3303</a><a id="L3304" href="#L3304">3304</a><a id="L3305" href="#L3305">3305</a><a id="L3306" href="#L3306">3306</a><a id="L3307" href="#L3307">3307</a><a id="L3308" href="#L3308">3308</a><a id="L3309" href="#L3309">3309</a><a id="L3310" href="#L3310">3310</a><a id="L3311" href="#L3311">3311</a><a id="L3312" href="#L3312">3312</a><a id="L3313" href="#L3313">3313</a><a id="L3314" href="#L3314">3314</a><a id="L3315" href="#L3315">3315</a><a id="L3316" href="#L3316">3316</a><a id="L3317" href="#L3317">3317</a><a id="L3318" href="#L3318">3318</a><a id="L3319" href="#L3319">3319</a><a id="L3320" href="#L3320">3320</a><a id="L3321" href="#L3321">3321</a><a id="L3322" href="#L3322">3322</a><a id="L3323" href="#L3323">3323</a><a id="L3324" href="#L3324">3324</a><a id="L3325" href="#L3325">3325</a><a id="L3326" href="#L3326">3326</a><a id="L3327" href="#L3327">3327</a><a id="L3328" href="#L3328">3328</a><a id="L3329" href="#L3329">3329</a><a id="L3330" href="#L3330">3330</a><a id="L3331" href="#L3331">3331</a><a id="L3332" href="#L3332">3332</a><a id="L3333" href="#L3333">3333</a><a id="L3334" href="#L3334">3334</a><a id="L3335" href="#L3335">3335</a><a id="L3336" href="#L3336">3336</a><a id="L3337" href="#L3337">3337</a><a id="L3338" href="#L3338">3338</a><a id="L3339" href="#L3339">3339</a><a id="L3340" href="#L3340">3340</a><a id="L3341" href="#L3341">3341</a><a id="L3342" href="#L3342">3342</a><a id="L3343" href="#L3343">3343</a><a id="L3344" href="#L3344">3344</a><a id="L3345" href="#L3345">3345</a><a id="L3346" href="#L3346">3346</a><a id="L3347" href="#L3347">3347</a><a id="L3348" href="#L3348">3348</a><a id="L3349" href="#L3349">3349</a><a id="L3350" href="#L3350">3350</a><a id="L3351" href="#L3351">3351</a><a id="L3352" href="#L3352">3352</a><a id="L3353" href="#L3353">3353</a><a id="L3354" href="#L3354">3354</a><a id="L3355" href="#L3355">3355</a><a id="L3356" href="#L3356">3356</a><a id="L3357" href="#L3357">3357</a><a id="L3358" href="#L3358">3358</a><a id="L3359" href="#L3359">3359</a><a id="L3360" href="#L3360">3360</a><a id="L3361" href="#L3361">3361</a><a id="L3362" href="#L3362">3362</a><a id="L3363" href="#L3363">3363</a><a id="L3364" href="#L3364">3364</a><a id="L3365" href="#L3365">3365</a><a id="L3366" href="#L3366">3366</a><a id="L3367" href="#L3367">3367</a><a id="L3368" href="#L3368">3368</a><a id="L3369" href="#L3369">3369</a><a id="L3370" href="#L3370">3370</a><a id="L3371" href="#L3371">3371</a><a id="L3372" href="#L3372">3372</a><a id="L3373" href="#L3373">3373</a><a id="L3374" href="#L3374">3374</a><a id="L3375" href="#L3375">3375</a><a id="L3376" href="#L3376">3376</a><a id="L3377" href="#L3377">3377</a><a id="L3378" href="#L3378">3378</a><a id="L3379" href="#L3379">3379</a><a id="L3380" href="#L3380">3380</a><a id="L3381" href="#L3381">3381</a><a id="L3382" href="#L3382">3382</a><a id="L3383" href="#L3383">3383</a><a id="L3384" href="#L3384">3384</a><a id="L3385" href="#L3385">3385</a><a id="L3386" href="#L3386">3386</a><a id="L3387" href="#L3387">3387</a><a id="L3388" href="#L3388">3388</a><a id="L3389" href="#L3389">3389</a><a id="L3390" href="#L3390">3390</a><a id="L3391" href="#L3391">3391</a><a id="L3392" href="#L3392">3392</a><a id="L3393" href="#L3393">3393</a><a id="L3394" href="#L3394">3394</a><a id="L3395" href="#L3395">3395</a><a id="L3396" href="#L3396">3396</a><a id="L3397" href="#L3397">3397</a><a id="L3398" href="#L3398">3398</a><a id="L3399" href="#L3399">3399</a><a id="L3400" href="#L3400">3400</a><a id="L3401" href="#L3401">3401</a><a id="L3402" href="#L3402">3402</a><a id="L3403" href="#L3403">3403</a><a id="L3404" href="#L3404">3404</a><a id="L3405" href="#L3405">3405</a><a id="L3406" href="#L3406">3406</a><a id="L3407" href="#L3407">3407</a><a id="L3408" href="#L3408">3408</a><a id="L3409" href="#L3409">3409</a><a id="L3410" href="#L3410">3410</a><a id="L3411" href="#L3411">3411</a><a id="L3412" href="#L3412">3412</a><a id="L3413" href="#L3413">3413</a><a id="L3414" href="#L3414">3414</a><a id="L3415" href="#L3415">3415</a><a id="L3416" href="#L3416">3416</a><a id="L3417" href="#L3417">3417</a><a id="L3418" href="#L3418">3418</a><a id="L3419" href="#L3419">3419</a><a id="L3420" href="#L3420">3420</a><a id="L3421" href="#L3421">3421</a><a id="L3422" href="#L3422">3422</a><a id="L3423" href="#L3423">3423</a><a id="L3424" href="#L3424">3424</a><a id="L3425" href="#L3425">3425</a><a id="L3426" href="#L3426">3426</a><a id="L3427" href="#L3427">3427</a><a id="L3428" href="#L3428">3428</a><a id="L3429" href="#L3429">3429</a><a id="L3430" href="#L3430">3430</a><a id="L3431" href="#L3431">3431</a><a id="L3432" href="#L3432">3432</a><a id="L3433" href="#L3433">3433</a><a id="L3434" href="#L3434">3434</a><a id="L3435" href="#L3435">3435</a><a id="L3436" href="#L3436">3436</a><a id="L3437" href="#L3437">3437</a><a id="L3438" href="#L3438">3438</a><a id="L3439" href="#L3439">3439</a><a id="L3440" href="#L3440">3440</a><a id="L3441" href="#L3441">3441</a><a id="L3442" href="#L3442">3442</a><a id="L3443" href="#L3443">3443</a><a id="L3444" href="#L3444">3444</a><a id="L3445" href="#L3445">3445</a><a id="L3446" href="#L3446">3446</a><a id="L3447" href="#L3447">3447</a><a id="L3448" href="#L3448">3448</a><a id="L3449" href="#L3449">3449</a><a id="L3450" href="#L3450">3450</a><a id="L3451" href="#L3451">3451</a><a id="L3452" href="#L3452">3452</a><a id="L3453" href="#L3453">3453</a><a id="L3454" href="#L3454">3454</a><a id="L3455" href="#L3455">3455</a><a id="L3456" href="#L3456">3456</a><a id="L3457" href="#L3457">3457</a><a id="L3458" href="#L3458">3458</a><a id="L3459" href="#L3459">3459</a><a id="L3460" href="#L3460">3460</a><a id="L3461" href="#L3461">3461</a><a id="L3462" href="#L3462">3462</a><a id="L3463" href="#L3463">3463</a><a id="L3464" href="#L3464">3464</a><a id="L3465" href="#L3465">3465</a><a id="L3466" href="#L3466">3466</a><a id="L3467" href="#L3467">3467</a><a id="L3468" href="#L3468">3468</a><a id="L3469" href="#L3469">3469</a><a id="L3470" href="#L3470">3470</a><a id="L3471" href="#L3471">3471</a><a id="L3472" href="#L3472">3472</a><a id="L3473" href="#L3473">3473</a><a id="L3474" href="#L3474">3474</a><a id="L3475" href="#L3475">3475</a><a id="L3476" href="#L3476">3476</a><a id="L3477" href="#L3477">3477</a><a id="L3478" href="#L3478">3478</a><a id="L3479" href="#L3479">3479</a><a id="L3480" href="#L3480">3480</a><a id="L3481" href="#L3481">3481</a><a id="L3482" href="#L3482">3482</a><a id="L3483" href="#L3483">3483</a><a id="L3484" href="#L3484">3484</a><a id="L3485" href="#L3485">3485</a><a id="L3486" href="#L3486">3486</a><a id="L3487" href="#L3487">3487</a><a id="L3488" href="#L3488">3488</a><a id="L3489" href="#L3489">3489</a><a id="L3490" href="#L3490">3490</a><a id="L3491" href="#L3491">3491</a><a id="L3492" href="#L3492">3492</a><a id="L3493" href="#L3493">3493</a><a id="L3494" href="#L3494">3494</a><a id="L3495" href="#L3495">3495</a><a id="L3496" href="#L3496">3496</a><a id="L3497" href="#L3497">3497</a><a id="L3498" href="#L3498">3498</a><a id="L3499" href="#L3499">3499</a><a id="L3500" href="#L3500">3500</a><a id="L3501" href="#L3501">3501</a><a id="L3502" href="#L3502">3502</a><a id="L3503" href="#L3503">3503</a><a id="L3504" href="#L3504">3504</a><a id="L3505" href="#L3505">3505</a><a id="L3506" href="#L3506">3506</a><a id="L3507" href="#L3507">3507</a><a id="L3508" href="#L3508">3508</a><a id="L3509" href="#L3509">3509</a><a id="L3510" href="#L3510">3510</a><a id="L3511" href="#L3511">3511</a><a id="L3512" href="#L3512">3512</a><a id="L3513" href="#L3513">3513</a><a id="L3514" href="#L3514">3514</a><a id="L3515" href="#L3515">3515</a><a id="L3516" href="#L3516">3516</a><a id="L3517" href="#L3517">3517</a><a id="L3518" href="#L3518">3518</a><a id="L3519" href="#L3519">3519</a><a id="L3520" href="#L3520">3520</a><a id="L3521" href="#L3521">3521</a><a id="L3522" href="#L3522">3522</a><a id="L3523" href="#L3523">3523</a><a id="L3524" href="#L3524">3524</a><a id="L3525" href="#L3525">3525</a><a id="L3526" href="#L3526">3526</a><a id="L3527" href="#L3527">3527</a><a id="L3528" href="#L3528">3528</a><a id="L3529" href="#L3529">3529</a><a id="L3530" href="#L3530">3530</a><a id="L3531" href="#L3531">3531</a><a id="L3532" href="#L3532">3532</a><a id="L3533" href="#L3533">3533</a><a id="L3534" href="#L3534">3534</a><a id="L3535" href="#L3535">3535</a><a id="L3536" href="#L3536">3536</a><a id="L3537" href="#L3537">3537</a><a id="L3538" href="#L3538">3538</a><a id="L3539" href="#L3539">3539</a><a id="L3540" href="#L3540">3540</a><a id="L3541" href="#L3541">3541</a><a id="L3542" href="#L3542">3542</a><a id="L3543" href="#L3543">3543</a><a id="L3544" href="#L3544">3544</a><a id="L3545" href="#L3545">3545</a><a id="L3546" href="#L3546">3546</a><a id="L3547" href="#L3547">3547</a><a id="L3548" href="#L3548">3548</a><a id="L3549" href="#L3549">3549</a><a id="L3550" href="#L3550">3550</a><a id="L3551" href="#L3551">3551</a><a id="L3552" href="#L3552">3552</a><a id="L3553" href="#L3553">3553</a><a id="L3554" href="#L3554">3554</a><a id="L3555" href="#L3555">3555</a><a id="L3556" href="#L3556">3556</a><a id="L3557" href="#L3557">3557</a><a id="L3558" href="#L3558">3558</a><a id="L3559" href="#L3559">3559</a><a id="L3560" href="#L3560">3560</a><a id="L3561" href="#L3561">3561</a><a id="L3562" href="#L3562">3562</a><a id="L3563" href="#L3563">3563</a><a id="L3564" href="#L3564">3564</a><a id="L3565" href="#L3565">3565</a><a id="L3566" href="#L3566">3566</a><a id="L3567" href="#L3567">3567</a><a id="L3568" href="#L3568">3568</a><a id="L3569" href="#L3569">3569</a><a id="L3570" href="#L3570">3570</a><a id="L3571" href="#L3571">3571</a><a id="L3572" href="#L3572">3572</a><a id="L3573" href="#L3573">3573</a><a id="L3574" href="#L3574">3574</a><a id="L3575" href="#L3575">3575</a><a id="L3576" href="#L3576">3576</a><a id="L3577" href="#L3577">3577</a><a id="L3578" href="#L3578">3578</a><a id="L3579" href="#L3579">3579</a><a id="L3580" href="#L3580">3580</a><a id="L3581" href="#L3581">3581</a><a id="L3582" href="#L3582">3582</a><a id="L3583" href="#L3583">3583</a><a id="L3584" href="#L3584">3584</a><a id="L3585" href="#L3585">3585</a><a id="L3586" href="#L3586">3586</a><a id="L3587" href="#L3587">3587</a><a id="L3588" href="#L3588">3588</a><a id="L3589" href="#L3589">3589</a><a id="L3590" href="#L3590">3590</a><a id="L3591" href="#L3591">3591</a><a id="L3592" href="#L3592">3592</a><a id="L3593" href="#L3593">3593</a><a id="L3594" href="#L3594">3594</a><a id="L3595" href="#L3595">3595</a><a id="L3596" href="#L3596">3596</a><a id="L3597" href="#L3597">3597</a><a id="L3598" href="#L3598">3598</a><a id="L3599" href="#L3599">3599</a><a id="L3600" href="#L3600">3600</a><a id="L3601" href="#L3601">3601</a><a id="L3602" href="#L3602">3602</a><a id="L3603" href="#L3603">3603</a><a id="L3604" href="#L3604">3604</a><a id="L3605" href="#L3605">3605</a><a id="L3606" href="#L3606">3606</a><a id="L3607" href="#L3607">3607</a><a id="L3608" href="#L3608">3608</a><a id="L3609" href="#L3609">3609</a><a id="L3610" href="#L3610">3610</a><a id="L3611" href="#L3611">3611</a><a id="L3612" href="#L3612">3612</a><a id="L3613" href="#L3613">3613</a><a id="L3614" href="#L3614">3614</a><a id="L3615" href="#L3615">3615</a><a id="L3616" href="#L3616">3616</a><a id="L3617" href="#L3617">3617</a><a id="L3618" href="#L3618">3618</a><a id="L3619" href="#L3619">3619</a><a id="L3620" href="#L3620">3620</a><a id="L3621" href="#L3621">3621</a><a id="L3622" href="#L3622">3622</a><a id="L3623" href="#L3623">3623</a><a id="L3624" href="#L3624">3624</a><a id="L3625" href="#L3625">3625</a><a id="L3626" href="#L3626">3626</a><a id="L3627" href="#L3627">3627</a><a id="L3628" href="#L3628">3628</a><a id="L3629" href="#L3629">3629</a><a id="L3630" href="#L3630">3630</a><a id="L3631" href="#L3631">3631</a><a id="L3632" href="#L3632">3632</a><a id="L3633" href="#L3633">3633</a><a id="L3634" href="#L3634">3634</a><a id="L3635" href="#L3635">3635</a><a id="L3636" href="#L3636">3636</a><a id="L3637" href="#L3637">3637</a><a id="L3638" href="#L3638">3638</a><a id="L3639" href="#L3639">3639</a><a id="L3640" href="#L3640">3640</a><a id="L3641" href="#L3641">3641</a><a id="L3642" href="#L3642">3642</a><a id="L3643" href="#L3643">3643</a><a id="L3644" href="#L3644">3644</a><a id="L3645" href="#L3645">3645</a><a id="L3646" href="#L3646">3646</a><a id="L3647" href="#L3647">3647</a><a id="L3648" href="#L3648">3648</a><a id="L3649" href="#L3649">3649</a><a id="L3650" href="#L3650">3650</a><a id="L3651" href="#L3651">3651</a><a id="L3652" href="#L3652">3652</a><a id="L3653" href="#L3653">3653</a><a id="L3654" href="#L3654">3654</a><a id="L3655" href="#L3655">3655</a><a id="L3656" href="#L3656">3656</a><a id="L3657" href="#L3657">3657</a><a id="L3658" href="#L3658">3658</a><a id="L3659" href="#L3659">3659</a><a id="L3660" href="#L3660">3660</a><a id="L3661" href="#L3661">3661</a><a id="L3662" href="#L3662">3662</a><a id="L3663" href="#L3663">3663</a><a id="L3664" href="#L3664">3664</a><a id="L3665" href="#L3665">3665</a><a id="L3666" href="#L3666">3666</a><a id="L3667" href="#L3667">3667</a><a id="L3668" href="#L3668">3668</a><a id="L3669" href="#L3669">3669</a><a id="L3670" href="#L3670">3670</a><a id="L3671" href="#L3671">3671</a><a id="L3672" href="#L3672">3672</a><a id="L3673" href="#L3673">3673</a><a id="L3674" href="#L3674">3674</a><a id="L3675" href="#L3675">3675</a><a id="L3676" href="#L3676">3676</a><a id="L3677" href="#L3677">3677</a><a id="L3678" href="#L3678">3678</a><a id="L3679" href="#L3679">3679</a><a id="L3680" href="#L3680">3680</a><a id="L3681" href="#L3681">3681</a><a id="L3682" href="#L3682">3682</a><a id="L3683" href="#L3683">3683</a><a id="L3684" href="#L3684">3684</a><a id="L3685" href="#L3685">3685</a><a id="L3686" href="#L3686">3686</a><a id="L3687" href="#L3687">3687</a><a id="L3688" href="#L3688">3688</a><a id="L3689" href="#L3689">3689</a><a id="L3690" href="#L3690">3690</a><a id="L3691" href="#L3691">3691</a><a id="L3692" href="#L3692">3692</a><a id="L3693" href="#L3693">3693</a><a id="L3694" href="#L3694">3694</a><a id="L3695" href="#L3695">3695</a><a id="L3696" href="#L3696">3696</a><a id="L3697" href="#L3697">3697</a><a id="L3698" href="#L3698">3698</a><a id="L3699" href="#L3699">3699</a><a id="L3700" href="#L3700">3700</a><a id="L3701" href="#L3701">3701</a><a id="L3702" href="#L3702">3702</a><a id="L3703" href="#L3703">3703</a><a id="L3704" href="#L3704">3704</a><a id="L3705" href="#L3705">3705</a><a id="L3706" href="#L3706">3706</a><a id="L3707" href="#L3707">3707</a><a id="L3708" href="#L3708">3708</a><a id="L3709" href="#L3709">3709</a><a id="L3710" href="#L3710">3710</a><a id="L3711" href="#L3711">3711</a><a id="L3712" href="#L3712">3712</a><a id="L3713" href="#L3713">3713</a><a id="L3714" href="#L3714">3714</a><a id="L3715" href="#L3715">3715</a><a id="L3716" href="#L3716">3716</a><a id="L3717" href="#L3717">3717</a><a id="L3718" href="#L3718">3718</a><a id="L3719" href="#L3719">3719</a><a id="L3720" href="#L3720">3720</a><a id="L3721" href="#L3721">3721</a><a id="L3722" href="#L3722">3722</a><a id="L3723" href="#L3723">3723</a><a id="L3724" href="#L3724">3724</a><a id="L3725" href="#L3725">3725</a><a id="L3726" href="#L3726">3726</a><a id="L3727" href="#L3727">3727</a><a id="L3728" href="#L3728">3728</a><a id="L3729" href="#L3729">3729</a><a id="L3730" href="#L3730">3730</a><a id="L3731" href="#L3731">3731</a><a id="L3732" href="#L3732">3732</a><a id="L3733" href="#L3733">3733</a><a id="L3734" href="#L3734">3734</a><a id="L3735" href="#L3735">3735</a><a id="L3736" href="#L3736">3736</a><a id="L3737" href="#L3737">3737</a><a id="L3738" href="#L3738">3738</a><a id="L3739" href="#L3739">3739</a><a id="L3740" href="#L3740">3740</a><a id="L3741" href="#L3741">3741</a><a id="L3742" href="#L3742">3742</a><a id="L3743" href="#L3743">3743</a><a id="L3744" href="#L3744">3744</a><a id="L3745" href="#L3745">3745</a><a id="L3746" href="#L3746">3746</a><a id="L3747" href="#L3747">3747</a><a id="L3748" href="#L3748">3748</a><a id="L3749" href="#L3749">3749</a><a id="L3750" href="#L3750">3750</a><a id="L3751" href="#L3751">3751</a><a id="L3752" href="#L3752">3752</a><a id="L3753" href="#L3753">3753</a><a id="L3754" href="#L3754">3754</a><a id="L3755" href="#L3755">3755</a><a id="L3756" href="#L3756">3756</a><a id="L3757" href="#L3757">3757</a><a id="L3758" href="#L3758">3758</a><a id="L3759" href="#L3759">3759</a><a id="L3760" href="#L3760">3760</a><a id="L3761" href="#L3761">3761</a><a id="L3762" href="#L3762">3762</a><a id="L3763" href="#L3763">3763</a><a id="L3764" href="#L3764">3764</a><a id="L3765" href="#L3765">3765</a><a id="L3766" href="#L3766">3766</a><a id="L3767" href="#L3767">3767</a><a id="L3768" href="#L3768">3768</a><a id="L3769" href="#L3769">3769</a><a id="L3770" href="#L3770">3770</a><a id="L3771" href="#L3771">3771</a><a id="L3772" href="#L3772">3772</a><a id="L3773" href="#L3773">3773</a><a id="L3774" href="#L3774">3774</a><a id="L3775" href="#L3775">3775</a><a id="L3776" href="#L3776">3776</a><a id="L3777" href="#L3777">3777</a><a id="L3778" href="#L3778">3778</a><a id="L3779" href="#L3779">3779</a><a id="L3780" href="#L3780">3780</a><a id="L3781" href="#L3781">3781</a><a id="L3782" href="#L3782">3782</a><a id="L3783" href="#L3783">3783</a><a id="L3784" href="#L3784">3784</a><a id="L3785" href="#L3785">3785</a><a id="L3786" href="#L3786">3786</a><a id="L3787" href="#L3787">3787</a><a id="L3788" href="#L3788">3788</a><a id="L3789" href="#L3789">3789</a><a id="L3790" href="#L3790">3790</a><a id="L3791" href="#L3791">3791</a><a id="L3792" href="#L3792">3792</a><a id="L3793" href="#L3793">3793</a><a id="L3794" href="#L3794">3794</a><a id="L3795" href="#L3795">3795</a><a id="L3796" href="#L3796">3796</a><a id="L3797" href="#L3797">3797</a><a id="L3798" href="#L3798">3798</a><a id="L3799" href="#L3799">3799</a><a id="L3800" href="#L3800">3800</a><a id="L3801" href="#L3801">3801</a><a id="L3802" href="#L3802">3802</a><a id="L3803" href="#L3803">3803</a><a id="L3804" href="#L3804">3804</a><a id="L3805" href="#L3805">3805</a><a id="L3806" href="#L3806">3806</a><a id="L3807" href="#L3807">3807</a><a id="L3808" href="#L3808">3808</a><a id="L3809" href="#L3809">3809</a><a id="L3810" href="#L3810">3810</a><a id="L3811" href="#L3811">3811</a><a id="L3812" href="#L3812">3812</a><a id="L3813" href="#L3813">3813</a><a id="L3814" href="#L3814">3814</a><a id="L3815" href="#L3815">3815</a><a id="L3816" href="#L3816">3816</a><a id="L3817" href="#L3817">3817</a><a id="L3818" href="#L3818">3818</a><a id="L3819" href="#L3819">3819</a><a id="L3820" href="#L3820">3820</a><a id="L3821" href="#L3821">3821</a><a id="L3822" href="#L3822">3822</a><a id="L3823" href="#L3823">3823</a><a id="L3824" href="#L3824">3824</a><a id="L3825" href="#L3825">3825</a><a id="L3826" href="#L3826">3826</a><a id="L3827" href="#L3827">3827</a><a id="L3828" href="#L3828">3828</a><a id="L3829" href="#L3829">3829</a><a id="L3830" href="#L3830">3830</a><a id="L3831" href="#L3831">3831</a><a id="L3832" href="#L3832">3832</a><a id="L3833" href="#L3833">3833</a><a id="L3834" href="#L3834">3834</a><a id="L3835" href="#L3835">3835</a><a id="L3836" href="#L3836">3836</a><a id="L3837" href="#L3837">3837</a><a id="L3838" href="#L3838">3838</a><a id="L3839" href="#L3839">3839</a><a id="L3840" href="#L3840">3840</a><a id="L3841" href="#L3841">3841</a><a id="L3842" href="#L3842">3842</a><a id="L3843" href="#L3843">3843</a><a id="L3844" href="#L3844">3844</a><a id="L3845" href="#L3845">3845</a><a id="L3846" href="#L3846">3846</a><a id="L3847" href="#L3847">3847</a><a id="L3848" href="#L3848">3848</a><a id="L3849" href="#L3849">3849</a><a id="L3850" href="#L3850">3850</a><a id="L3851" href="#L3851">3851</a><a id="L3852" href="#L3852">3852</a><a id="L3853" href="#L3853">3853</a><a id="L3854" href="#L3854">3854</a><a id="L3855" href="#L3855">3855</a><a id="L3856" href="#L3856">3856</a><a id="L3857" href="#L3857">3857</a><a id="L3858" href="#L3858">3858</a><a id="L3859" href="#L3859">3859</a><a id="L3860" href="#L3860">3860</a><a id="L3861" href="#L3861">3861</a><a id="L3862" href="#L3862">3862</a><a id="L3863" href="#L3863">3863</a><a id="L3864" href="#L3864">3864</a><a id="L3865" href="#L3865">3865</a><a id="L3866" href="#L3866">3866</a><a id="L3867" href="#L3867">3867</a><a id="L3868" href="#L3868">3868</a><a id="L3869" href="#L3869">3869</a><a id="L3870" href="#L3870">3870</a><a id="L3871" href="#L3871">3871</a><a id="L3872" href="#L3872">3872</a><a id="L3873" href="#L3873">3873</a><a id="L3874" href="#L3874">3874</a><a id="L3875" href="#L3875">3875</a><a id="L3876" href="#L3876">3876</a><a id="L3877" href="#L3877">3877</a><a id="L3878" href="#L3878">3878</a><a id="L3879" href="#L3879">3879</a><a id="L3880" href="#L3880">3880</a><a id="L3881" href="#L3881">3881</a><a id="L3882" href="#L3882">3882</a><a id="L3883" href="#L3883">3883</a><a id="L3884" href="#L3884">3884</a><a id="L3885" href="#L3885">3885</a><a id="L3886" href="#L3886">3886</a><a id="L3887" href="#L3887">3887</a><a id="L3888" href="#L3888">3888</a><a id="L3889" href="#L3889">3889</a><a id="L3890" href="#L3890">3890</a><a id="L3891" href="#L3891">3891</a><a id="L3892" href="#L3892">3892</a><a id="L3893" href="#L3893">3893</a><a id="L3894" href="#L3894">3894</a><a id="L3895" href="#L3895">3895</a><a id="L3896" href="#L3896">3896</a><a id="L3897" href="#L3897">3897</a><a id="L3898" href="#L3898">3898</a><a id="L3899" href="#L3899">3899</a><a id="L3900" href="#L3900">3900</a><a id="L3901" href="#L3901">3901</a><a id="L3902" href="#L3902">3902</a><a id="L3903" href="#L3903">3903</a><a id="L3904" href="#L3904">3904</a><a id="L3905" href="#L3905">3905</a><a id="L3906" href="#L3906">3906</a><a id="L3907" href="#L3907">3907</a><a id="L3908" href="#L3908">3908</a><a id="L3909" href="#L3909">3909</a><a id="L3910" href="#L3910">3910</a><a id="L3911" href="#L3911">3911</a><a id="L3912" href="#L3912">3912</a><a id="L3913" href="#L3913">3913</a><a id="L3914" href="#L3914">3914</a><a id="L3915" href="#L3915">3915</a><a id="L3916" href="#L3916">3916</a><a id="L3917" href="#L3917">3917</a><a id="L3918" href="#L3918">3918</a><a id="L3919" href="#L3919">3919</a><a id="L3920" href="#L3920">3920</a><a id="L3921" href="#L3921">3921</a><a id="L3922" href="#L3922">3922</a><a id="L3923" href="#L3923">3923</a><a id="L3924" href="#L3924">3924</a><a id="L3925" href="#L3925">3925</a><a id="L3926" href="#L3926">3926</a><a id="L3927" href="#L3927">3927</a><a id="L3928" href="#L3928">3928</a><a id="L3929" href="#L3929">3929</a><a id="L3930" href="#L3930">3930</a><a id="L3931" href="#L3931">3931</a><a id="L3932" href="#L3932">3932</a><a id="L3933" href="#L3933">3933</a><a id="L3934" href="#L3934">3934</a><a id="L3935" href="#L3935">3935</a><a id="L3936" href="#L3936">3936</a><a id="L3937" href="#L3937">3937</a><a id="L3938" href="#L3938">3938</a><a id="L3939" href="#L3939">3939</a><a id="L3940" href="#L3940">3940</a><a id="L3941" href="#L3941">3941</a><a id="L3942" href="#L3942">3942</a><a id="L3943" href="#L3943">3943</a><a id="L3944" href="#L3944">3944</a><a id="L3945" href="#L3945">3945</a><a id="L3946" href="#L3946">3946</a><a id="L3947" href="#L3947">3947</a><a id="L3948" href="#L3948">3948</a><a id="L3949" href="#L3949">3949</a><a id="L3950" href="#L3950">3950</a><a id="L3951" href="#L3951">3951</a><a id="L3952" href="#L3952">3952</a><a id="L3953" href="#L3953">3953</a><a id="L3954" href="#L3954">3954</a><a id="L3955" href="#L3955">3955</a><a id="L3956" href="#L3956">3956</a><a id="L3957" href="#L3957">3957</a><a id="L3958" href="#L3958">3958</a><a id="L3959" href="#L3959">3959</a><a id="L3960" href="#L3960">3960</a><a id="L3961" href="#L3961">3961</a><a id="L3962" href="#L3962">3962</a><a id="L3963" href="#L3963">3963</a><a id="L3964" href="#L3964">3964</a><a id="L3965" href="#L3965">3965</a><a id="L3966" href="#L3966">3966</a><a id="L3967" href="#L3967">3967</a><a id="L3968" href="#L3968">3968</a><a id="L3969" href="#L3969">3969</a><a id="L3970" href="#L3970">3970</a><a id="L3971" href="#L3971">3971</a><a id="L3972" href="#L3972">3972</a><a id="L3973" href="#L3973">3973</a><a id="L3974" href="#L3974">3974</a><a id="L3975" href="#L3975">3975</a><a id="L3976" href="#L3976">3976</a><a id="L3977" href="#L3977">3977</a><a id="L3978" href="#L3978">3978</a><a id="L3979" href="#L3979">3979</a><a id="L3980" href="#L3980">3980</a><a id="L3981" href="#L3981">3981</a><a id="L3982" href="#L3982">3982</a><a id="L3983" href="#L3983">3983</a><a id="L3984" href="#L3984">3984</a><a id="L3985" href="#L3985">3985</a><a id="L3986" href="#L3986">3986</a><a id="L3987" href="#L3987">3987</a><a id="L3988" href="#L3988">3988</a><a id="L3989" href="#L3989">3989</a><a id="L3990" href="#L3990">3990</a><a id="L3991" href="#L3991">3991</a><a id="L3992" href="#L3992">3992</a><a id="L3993" href="#L3993">3993</a><a id="L3994" href="#L3994">3994</a><a id="L3995" href="#L3995">3995</a><a id="L3996" href="#L3996">3996</a><a id="L3997" href="#L3997">3997</a><a id="L3998" href="#L3998">3998</a><a id="L3999" href="#L3999">3999</a><a id="L4000" href="#L4000">4000</a><a id="L4001" href="#L4001">4001</a><a id="L4002" href="#L4002">4002</a><a id="L4003" href="#L4003">4003</a><a id="L4004" href="#L4004">4004</a><a id="L4005" href="#L4005">4005</a><a id="L4006" href="#L4006">4006</a><a id="L4007" href="#L4007">4007</a><a id="L4008" href="#L4008">4008</a><a id="L4009" href="#L4009">4009</a><a id="L4010" href="#L4010">4010</a><a id="L4011" href="#L4011">4011</a><a id="L4012" href="#L4012">4012</a><a id="L4013" href="#L4013">4013</a><a id="L4014" href="#L4014">4014</a><a id="L4015" href="#L4015">4015</a><a id="L4016" href="#L4016">4016</a><a id="L4017" href="#L4017">4017</a><a id="L4018" href="#L4018">4018</a><a id="L4019" href="#L4019">4019</a><a id="L4020" href="#L4020">4020</a><a id="L4021" href="#L4021">4021</a><a id="L4022" href="#L4022">4022</a><a id="L4023" href="#L4023">4023</a><a id="L4024" href="#L4024">4024</a><a id="L4025" href="#L4025">4025</a><a id="L4026" href="#L4026">4026</a><a id="L4027" href="#L4027">4027</a><a id="L4028" href="#L4028">4028</a><a id="L4029" href="#L4029">4029</a><a id="L4030" href="#L4030">4030</a><a id="L4031" href="#L4031">4031</a><a id="L4032" href="#L4032">4032</a><a id="L4033" href="#L4033">4033</a><a id="L4034" href="#L4034">4034</a><a id="L4035" href="#L4035">4035</a><a id="L4036" href="#L4036">4036</a><a id="L4037" href="#L4037">4037</a><a id="L4038" href="#L4038">4038</a><a id="L4039" href="#L4039">4039</a><a id="L4040" href="#L4040">4040</a><a id="L4041" href="#L4041">4041</a><a id="L4042" href="#L4042">4042</a><a id="L4043" href="#L4043">4043</a><a id="L4044" href="#L4044">4044</a><a id="L4045" href="#L4045">4045</a><a id="L4046" href="#L4046">4046</a><a id="L4047" href="#L4047">4047</a><a id="L4048" href="#L4048">4048</a><a id="L4049" href="#L4049">4049</a><a id="L4050" href="#L4050">4050</a><a id="L4051" href="#L4051">4051</a><a id="L4052" href="#L4052">4052</a><a id="L4053" href="#L4053">4053</a><a id="L4054" href="#L4054">4054</a><a id="L4055" href="#L4055">4055</a><a id="L4056" href="#L4056">4056</a><a id="L4057" href="#L4057">4057</a><a id="L4058" href="#L4058">4058</a><a id="L4059" href="#L4059">4059</a><a id="L4060" href="#L4060">4060</a><a id="L4061" href="#L4061">4061</a><a id="L4062" href="#L4062">4062</a><a id="L4063" href="#L4063">4063</a><a id="L4064" href="#L4064">4064</a><a id="L4065" href="#L4065">4065</a><a id="L4066" href="#L4066">4066</a><a id="L4067" href="#L4067">4067</a><a id="L4068" href="#L4068">4068</a><a id="L4069" href="#L4069">4069</a><a id="L4070" href="#L4070">4070</a><a id="L4071" href="#L4071">4071</a><a id="L4072" href="#L4072">4072</a><a id="L4073" href="#L4073">4073</a><a id="L4074" href="#L4074">4074</a><a id="L4075" href="#L4075">4075</a><a id="L4076" href="#L4076">4076</a><a id="L4077" href="#L4077">4077</a><a id="L4078" href="#L4078">4078</a><a id="L4079" href="#L4079">4079</a><a id="L4080" href="#L4080">4080</a><a id="L4081" href="#L4081">4081</a><a id="L4082" href="#L4082">4082</a><a id="L4083" href="#L4083">4083</a><a id="L4084" href="#L4084">4084</a><a id="L4085" href="#L4085">4085</a><a id="L4086" href="#L4086">4086</a><a id="L4087" href="#L4087">4087</a><a id="L4088" href="#L4088">4088</a><a id="L4089" href="#L4089">4089</a><a id="L4090" href="#L4090">4090</a><a id="L4091" href="#L4091">4091</a><a id="L4092" href="#L4092">4092</a><a id="L4093" href="#L4093">4093</a><a id="L4094" href="#L4094">4094</a><a id="L4095" href="#L4095">4095</a><a id="L4096" href="#L4096">4096</a><a id="L4097" href="#L4097">4097</a><a id="L4098" href="#L4098">4098</a><a id="L4099" href="#L4099">4099</a><a id="L4100" href="#L4100">4100</a><a id="L4101" href="#L4101">4101</a><a id="L4102" href="#L4102">4102</a><a id="L4103" href="#L4103">4103</a><a id="L4104" href="#L4104">4104</a><a id="L4105" href="#L4105">4105</a><a id="L4106" href="#L4106">4106</a><a id="L4107" href="#L4107">4107</a><a id="L4108" href="#L4108">4108</a><a id="L4109" href="#L4109">4109</a><a id="L4110" href="#L4110">4110</a><a id="L4111" href="#L4111">4111</a><a id="L4112" href="#L4112">4112</a><a id="L4113" href="#L4113">4113</a><a id="L4114" href="#L4114">4114</a><a id="L4115" href="#L4115">4115</a><a id="L4116" href="#L4116">4116</a><a id="L4117" href="#L4117">4117</a><a id="L4118" href="#L4118">4118</a><a id="L4119" href="#L4119">4119</a><a id="L4120" href="#L4120">4120</a><a id="L4121" href="#L4121">4121</a><a id="L4122" href="#L4122">4122</a><a id="L4123" href="#L4123">4123</a><a id="L4124" href="#L4124">4124</a><a id="L4125" href="#L4125">4125</a><a id="L4126" href="#L4126">4126</a><a id="L4127" href="#L4127">4127</a><a id="L4128" href="#L4128">4128</a><a id="L4129" href="#L4129">4129</a><a id="L4130" href="#L4130">4130</a><a id="L4131" href="#L4131">4131</a><a id="L4132" href="#L4132">4132</a><a id="L4133" href="#L4133">4133</a><a id="L4134" href="#L4134">4134</a><a id="L4135" href="#L4135">4135</a><a id="L4136" href="#L4136">4136</a><a id="L4137" href="#L4137">4137</a><a id="L4138" href="#L4138">4138</a><a id="L4139" href="#L4139">4139</a><a id="L4140" href="#L4140">4140</a><a id="L4141" href="#L4141">4141</a><a id="L4142" href="#L4142">4142</a><a id="L4143" href="#L4143">4143</a><a id="L4144" href="#L4144">4144</a><a id="L4145" href="#L4145">4145</a><a id="L4146" href="#L4146">4146</a><a id="L4147" href="#L4147">4147</a><a id="L4148" href="#L4148">4148</a><a id="L4149" href="#L4149">4149</a><a id="L4150" href="#L4150">4150</a><a id="L4151" href="#L4151">4151</a><a id="L4152" href="#L4152">4152</a><a id="L4153" href="#L4153">4153</a><a id="L4154" href="#L4154">4154</a><a id="L4155" href="#L4155">4155</a><a id="L4156" href="#L4156">4156</a><a id="L4157" href="#L4157">4157</a><a id="L4158" href="#L4158">4158</a><a id="L4159" href="#L4159">4159</a><a id="L4160" href="#L4160">4160</a><a id="L4161" href="#L4161">4161</a><a id="L4162" href="#L4162">4162</a><a id="L4163" href="#L4163">4163</a><a id="L4164" href="#L4164">4164</a><a id="L4165" href="#L4165">4165</a><a id="L4166" href="#L4166">4166</a><a id="L4167" href="#L4167">4167</a><a id="L4168" href="#L4168">4168</a><a id="L4169" href="#L4169">4169</a><a id="L4170" href="#L4170">4170</a><a id="L4171" href="#L4171">4171</a><a id="L4172" href="#L4172">4172</a><a id="L4173" href="#L4173">4173</a><a id="L4174" href="#L4174">4174</a><a id="L4175" href="#L4175">4175</a><a id="L4176" href="#L4176">4176</a><a id="L4177" href="#L4177">4177</a><a id="L4178" href="#L4178">4178</a><a id="L4179" href="#L4179">4179</a><a id="L4180" href="#L4180">4180</a><a id="L4181" href="#L4181">4181</a><a id="L4182" href="#L4182">4182</a><a id="L4183" href="#L4183">4183</a><a id="L4184" href="#L4184">4184</a><a id="L4185" href="#L4185">4185</a><a id="L4186" href="#L4186">4186</a><a id="L4187" href="#L4187">4187</a><a id="L4188" href="#L4188">4188</a><a id="L4189" href="#L4189">4189</a><a id="L4190" href="#L4190">4190</a><a id="L4191" href="#L4191">4191</a><a id="L4192" href="#L4192">4192</a><a id="L4193" href="#L4193">4193</a><a id="L4194" href="#L4194">4194</a><a id="L4195" href="#L4195">4195</a><a id="L4196" href="#L4196">4196</a><a id="L4197" href="#L4197">4197</a><a id="L4198" href="#L4198">4198</a><a id="L4199" href="#L4199">4199</a><a id="L4200" href="#L4200">4200</a><a id="L4201" href="#L4201">4201</a><a id="L4202" href="#L4202">4202</a><a id="L4203" href="#L4203">4203</a><a id="L4204" href="#L4204">4204</a><a id="L4205" href="#L4205">4205</a><a id="L4206" href="#L4206">4206</a><a id="L4207" href="#L4207">4207</a><a id="L4208" href="#L4208">4208</a><a id="L4209" href="#L4209">4209</a><a id="L4210" href="#L4210">4210</a><a id="L4211" href="#L4211">4211</a><a id="L4212" href="#L4212">4212</a><a id="L4213" href="#L4213">4213</a><a id="L4214" href="#L4214">4214</a><a id="L4215" href="#L4215">4215</a><a id="L4216" href="#L4216">4216</a><a id="L4217" href="#L4217">4217</a><a id="L4218" href="#L4218">4218</a><a id="L4219" href="#L4219">4219</a><a id="L4220" href="#L4220">4220</a><a id="L4221" href="#L4221">4221</a><a id="L4222" href="#L4222">4222</a><a id="L4223" href="#L4223">4223</a><a id="L4224" href="#L4224">4224</a><a id="L4225" href="#L4225">4225</a><a id="L4226" href="#L4226">4226</a><a id="L4227" href="#L4227">4227</a><a id="L4228" href="#L4228">4228</a><a id="L4229" href="#L4229">4229</a><a id="L4230" href="#L4230">4230</a><a id="L4231" href="#L4231">4231</a><a id="L4232" href="#L4232">4232</a><a id="L4233" href="#L4233">4233</a><a id="L4234" href="#L4234">4234</a><a id="L4235" href="#L4235">4235</a><a id="L4236" href="#L4236">4236</a><a id="L4237" href="#L4237">4237</a><a id="L4238" href="#L4238">4238</a><a id="L4239" href="#L4239">4239</a><a id="L4240" href="#L4240">4240</a><a id="L4241" href="#L4241">4241</a><a id="L4242" href="#L4242">4242</a><a id="L4243" href="#L4243">4243</a><a id="L4244" href="#L4244">4244</a><a id="L4245" href="#L4245">4245</a><a id="L4246" href="#L4246">4246</a><a id="L4247" href="#L4247">4247</a><a id="L4248" href="#L4248">4248</a><a id="L4249" href="#L4249">4249</a><a id="L4250" href="#L4250">4250</a><a id="L4251" href="#L4251">4251</a><a id="L4252" href="#L4252">4252</a><a id="L4253" href="#L4253">4253</a><a id="L4254" href="#L4254">4254</a><a id="L4255" href="#L4255">4255</a><a id="L4256" href="#L4256">4256</a><a id="L4257" href="#L4257">4257</a><a id="L4258" href="#L4258">4258</a><a id="L4259" href="#L4259">4259</a><a id="L4260" href="#L4260">4260</a><a id="L4261" href="#L4261">4261</a><a id="L4262" href="#L4262">4262</a><a id="L4263" href="#L4263">4263</a><a id="L4264" href="#L4264">4264</a><a id="L4265" href="#L4265">4265</a><a id="L4266" href="#L4266">4266</a><a id="L4267" href="#L4267">4267</a><a id="L4268" href="#L4268">4268</a><a id="L4269" href="#L4269">4269</a><a id="L4270" href="#L4270">4270</a><a id="L4271" href="#L4271">4271</a><a id="L4272" href="#L4272">4272</a><a id="L4273" href="#L4273">4273</a><a id="L4274" href="#L4274">4274</a><a id="L4275" href="#L4275">4275</a><a id="L4276" href="#L4276">4276</a><a id="L4277" href="#L4277">4277</a><a id="L4278" href="#L4278">4278</a><a id="L4279" href="#L4279">4279</a><a id="L4280" href="#L4280">4280</a><a id="L4281" href="#L4281">4281</a><a id="L4282" href="#L4282">4282</a><a id="L4283" href="#L4283">4283</a><a id="L4284" href="#L4284">4284</a><a id="L4285" href="#L4285">4285</a><a id="L4286" href="#L4286">4286</a><a id="L4287" href="#L4287">4287</a><a id="L4288" href="#L4288">4288</a><a id="L4289" href="#L4289">4289</a><a id="L4290" href="#L4290">4290</a><a id="L4291" href="#L4291">4291</a><a id="L4292" href="#L4292">4292</a><a id="L4293" href="#L4293">4293</a><a id="L4294" href="#L4294">4294</a><a id="L4295" href="#L4295">4295</a><a id="L4296" href="#L4296">4296</a><a id="L4297" href="#L4297">4297</a><a id="L4298" href="#L4298">4298</a><a id="L4299" href="#L4299">4299</a><a id="L4300" href="#L4300">4300</a><a id="L4301" href="#L4301">4301</a><a id="L4302" href="#L4302">4302</a><a id="L4303" href="#L4303">4303</a><a id="L4304" href="#L4304">4304</a><a id="L4305" href="#L4305">4305</a><a id="L4306" href="#L4306">4306</a><a id="L4307" href="#L4307">4307</a><a id="L4308" href="#L4308">4308</a><a id="L4309" href="#L4309">4309</a><a id="L4310" href="#L4310">4310</a><a id="L4311" href="#L4311">4311</a><a id="L4312" href="#L4312">4312</a><a id="L4313" href="#L4313">4313</a><a id="L4314" href="#L4314">4314</a><a id="L4315" href="#L4315">4315</a><a id="L4316" href="#L4316">4316</a><a id="L4317" href="#L4317">4317</a><a id="L4318" href="#L4318">4318</a><a id="L4319" href="#L4319">4319</a><a id="L4320" href="#L4320">4320</a><a id="L4321" href="#L4321">4321</a><a id="L4322" href="#L4322">4322</a><a id="L4323" href="#L4323">4323</a><a id="L4324" href="#L4324">4324</a><a id="L4325" href="#L4325">4325</a><a id="L4326" href="#L4326">4326</a><a id="L4327" href="#L4327">4327</a><a id="L4328" href="#L4328">4328</a><a id="L4329" href="#L4329">4329</a><a id="L4330" href="#L4330">4330</a><a id="L4331" href="#L4331">4331</a><a id="L4332" href="#L4332">4332</a><a id="L4333" href="#L4333">4333</a><a id="L4334" href="#L4334">4334</a><a id="L4335" href="#L4335">4335</a><a id="L4336" href="#L4336">4336</a><a id="L4337" href="#L4337">4337</a><a id="L4338" href="#L4338">4338</a><a id="L4339" href="#L4339">4339</a><a id="L4340" href="#L4340">4340</a><a id="L4341" href="#L4341">4341</a><a id="L4342" href="#L4342">4342</a><a id="L4343" href="#L4343">4343</a><a id="L4344" href="#L4344">4344</a><a id="L4345" href="#L4345">4345</a><a id="L4346" href="#L4346">4346</a><a id="L4347" href="#L4347">4347</a><a id="L4348" href="#L4348">4348</a><a id="L4349" href="#L4349">4349</a><a id="L4350" href="#L4350">4350</a><a id="L4351" href="#L4351">4351</a><a id="L4352" href="#L4352">4352</a><a id="L4353" href="#L4353">4353</a><a id="L4354" href="#L4354">4354</a><a id="L4355" href="#L4355">4355</a><a id="L4356" href="#L4356">4356</a><a id="L4357" href="#L4357">4357</a><a id="L4358" href="#L4358">4358</a><a id="L4359" href="#L4359">4359</a><a id="L4360" href="#L4360">4360</a><a id="L4361" href="#L4361">4361</a><a id="L4362" href="#L4362">4362</a><a id="L4363" href="#L4363">4363</a><a id="L4364" href="#L4364">4364</a><a id="L4365" href="#L4365">4365</a><a id="L4366" href="#L4366">4366</a><a id="L4367" href="#L4367">4367</a><a id="L4368" href="#L4368">4368</a><a id="L4369" href="#L4369">4369</a><a id="L4370" href="#L4370">4370</a><a id="L4371" href="#L4371">4371</a><a id="L4372" href="#L4372">4372</a><a id="L4373" href="#L4373">4373</a><a id="L4374" href="#L4374">4374</a><a id="L4375" href="#L4375">4375</a><a id="L4376" href="#L4376">4376</a><a id="L4377" href="#L4377">4377</a><a id="L4378" href="#L4378">4378</a><a id="L4379" href="#L4379">4379</a><a id="L4380" href="#L4380">4380</a><a id="L4381" href="#L4381">4381</a><a id="L4382" href="#L4382">4382</a><a id="L4383" href="#L4383">4383</a><a id="L4384" href="#L4384">4384</a><a id="L4385" href="#L4385">4385</a><a id="L4386" href="#L4386">4386</a><a id="L4387" href="#L4387">4387</a><a id="L4388" href="#L4388">4388</a><a id="L4389" href="#L4389">4389</a><a id="L4390" href="#L4390">4390</a><a id="L4391" href="#L4391">4391</a><a id="L4392" href="#L4392">4392</a><a id="L4393" href="#L4393">4393</a><a id="L4394" href="#L4394">4394</a><a id="L4395" href="#L4395">4395</a><a id="L4396" href="#L4396">4396</a><a id="L4397" href="#L4397">4397</a><a id="L4398" href="#L4398">4398</a><a id="L4399" href="#L4399">4399</a><a id="L4400" href="#L4400">4400</a><a id="L4401" href="#L4401">4401</a><a id="L4402" href="#L4402">4402</a><a id="L4403" href="#L4403">4403</a><a id="L4404" href="#L4404">4404</a><a id="L4405" href="#L4405">4405</a><a id="L4406" href="#L4406">4406</a><a id="L4407" href="#L4407">4407</a><a id="L4408" href="#L4408">4408</a><a id="L4409" href="#L4409">4409</a><a id="L4410" href="#L4410">4410</a><a id="L4411" href="#L4411">4411</a><a id="L4412" href="#L4412">4412</a><a id="L4413" href="#L4413">4413</a><a id="L4414" href="#L4414">4414</a><a id="L4415" href="#L4415">4415</a><a id="L4416" href="#L4416">4416</a><a id="L4417" href="#L4417">4417</a><a id="L4418" href="#L4418">4418</a><a id="L4419" href="#L4419">4419</a><a id="L4420" href="#L4420">4420</a><a id="L4421" href="#L4421">4421</a><a id="L4422" href="#L4422">4422</a><a id="L4423" href="#L4423">4423</a><a id="L4424" href="#L4424">4424</a><a id="L4425" href="#L4425">4425</a><a id="L4426" href="#L4426">4426</a><a id="L4427" href="#L4427">4427</a><a id="L4428" href="#L4428">4428</a><a id="L4429" href="#L4429">4429</a><a id="L4430" href="#L4430">4430</a><a id="L4431" href="#L4431">4431</a><a id="L4432" href="#L4432">4432</a><a id="L4433" href="#L4433">4433</a><a id="L4434" href="#L4434">4434</a><a id="L4435" href="#L4435">4435</a><a id="L4436" href="#L4436">4436</a><a id="L4437" href="#L4437">4437</a><a id="L4438" href="#L4438">4438</a><a id="L4439" href="#L4439">4439</a><a id="L4440" href="#L4440">4440</a><a id="L4441" href="#L4441">4441</a><a id="L4442" href="#L4442">4442</a><a id="L4443" href="#L4443">4443</a><a id="L4444" href="#L4444">4444</a><a id="L4445" href="#L4445">4445</a><a id="L4446" href="#L4446">4446</a><a id="L4447" href="#L4447">4447</a><a id="L4448" href="#L4448">4448</a><a id="L4449" href="#L4449">4449</a><a id="L4450" href="#L4450">4450</a><a id="L4451" href="#L4451">4451</a><a id="L4452" href="#L4452">4452</a><a id="L4453" href="#L4453">4453</a><a id="L4454" href="#L4454">4454</a><a id="L4455" href="#L4455">4455</a><a id="L4456" href="#L4456">4456</a><a id="L4457" href="#L4457">4457</a><a id="L4458" href="#L4458">4458</a><a id="L4459" href="#L4459">4459</a><a id="L4460" href="#L4460">4460</a><a id="L4461" href="#L4461">4461</a><a id="L4462" href="#L4462">4462</a><a id="L4463" href="#L4463">4463</a><a id="L4464" href="#L4464">4464</a><a id="L4465" href="#L4465">4465</a><a id="L4466" href="#L4466">4466</a><a id="L4467" href="#L4467">4467</a><a id="L4468" href="#L4468">4468</a><a id="L4469" href="#L4469">4469</a><a id="L4470" href="#L4470">4470</a><a id="L4471" href="#L4471">4471</a><a id="L4472" href="#L4472">4472</a><a id="L4473" href="#L4473">4473</a><a id="L4474" href="#L4474">4474</a><a id="L4475" href="#L4475">4475</a><a id="L4476" href="#L4476">4476</a><a id="L4477" href="#L4477">4477</a><a id="L4478" href="#L4478">4478</a><a id="L4479" href="#L4479">4479</a><a id="L4480" href="#L4480">4480</a><a id="L4481" href="#L4481">4481</a><a id="L4482" href="#L4482">4482</a><a id="L4483" href="#L4483">4483</a><a id="L4484" href="#L4484">4484</a><a id="L4485" href="#L4485">4485</a><a id="L4486" href="#L4486">4486</a><a id="L4487" href="#L4487">4487</a><a id="L4488" href="#L4488">4488</a><a id="L4489" href="#L4489">4489</a><a id="L4490" href="#L4490">4490</a><a id="L4491" href="#L4491">4491</a><a id="L4492" href="#L4492">4492</a><a id="L4493" href="#L4493">4493</a><a id="L4494" href="#L4494">4494</a><a id="L4495" href="#L4495">4495</a><a id="L4496" href="#L4496">4496</a><a id="L4497" href="#L4497">4497</a><a id="L4498" href="#L4498">4498</a><a id="L4499" href="#L4499">4499</a><a id="L4500" href="#L4500">4500</a><a id="L4501" href="#L4501">4501</a><a id="L4502" href="#L4502">4502</a><a id="L4503" href="#L4503">4503</a><a id="L4504" href="#L4504">4504</a><a id="L4505" href="#L4505">4505</a><a id="L4506" href="#L4506">4506</a><a id="L4507" href="#L4507">4507</a><a id="L4508" href="#L4508">4508</a><a id="L4509" href="#L4509">4509</a><a id="L4510" href="#L4510">4510</a><a id="L4511" href="#L4511">4511</a><a id="L4512" href="#L4512">4512</a><a id="L4513" href="#L4513">4513</a><a id="L4514" href="#L4514">4514</a><a id="L4515" href="#L4515">4515</a><a id="L4516" href="#L4516">4516</a><a id="L4517" href="#L4517">4517</a><a id="L4518" href="#L4518">4518</a><a id="L4519" href="#L4519">4519</a><a id="L4520" href="#L4520">4520</a><a id="L4521" href="#L4521">4521</a><a id="L4522" href="#L4522">4522</a><a id="L4523" href="#L4523">4523</a><a id="L4524" href="#L4524">4524</a><a id="L4525" href="#L4525">4525</a><a id="L4526" href="#L4526">4526</a><a id="L4527" href="#L4527">4527</a><a id="L4528" href="#L4528">4528</a><a id="L4529" href="#L4529">4529</a><a id="L4530" href="#L4530">4530</a><a id="L4531" href="#L4531">4531</a><a id="L4532" href="#L4532">4532</a><a id="L4533" href="#L4533">4533</a><a id="L4534" href="#L4534">4534</a><a id="L4535" href="#L4535">4535</a><a id="L4536" href="#L4536">4536</a><a id="L4537" href="#L4537">4537</a><a id="L4538" href="#L4538">4538</a><a id="L4539" href="#L4539">4539</a><a id="L4540" href="#L4540">4540</a><a id="L4541" href="#L4541">4541</a><a id="L4542" href="#L4542">4542</a><a id="L4543" href="#L4543">4543</a><a id="L4544" href="#L4544">4544</a><a id="L4545" href="#L4545">4545</a><a id="L4546" href="#L4546">4546</a><a id="L4547" href="#L4547">4547</a><a id="L4548" href="#L4548">4548</a><a id="L4549" href="#L4549">4549</a><a id="L4550" href="#L4550">4550</a><a id="L4551" href="#L4551">4551</a><a id="L4552" href="#L4552">4552</a><a id="L4553" href="#L4553">4553</a><a id="L4554" href="#L4554">4554</a><a id="L4555" href="#L4555">4555</a><a id="L4556" href="#L4556">4556</a><a id="L4557" href="#L4557">4557</a><a id="L4558" href="#L4558">4558</a><a id="L4559" href="#L4559">4559</a><a id="L4560" href="#L4560">4560</a><a id="L4561" href="#L4561">4561</a><a id="L4562" href="#L4562">4562</a><a id="L4563" href="#L4563">4563</a><a id="L4564" href="#L4564">4564</a><a id="L4565" href="#L4565">4565</a><a id="L4566" href="#L4566">4566</a><a id="L4567" href="#L4567">4567</a><a id="L4568" href="#L4568">4568</a><a id="L4569" href="#L4569">4569</a><a id="L4570" href="#L4570">4570</a><a id="L4571" href="#L4571">4571</a><a id="L4572" href="#L4572">4572</a><a id="L4573" href="#L4573">4573</a><a id="L4574" href="#L4574">4574</a><a id="L4575" href="#L4575">4575</a><a id="L4576" href="#L4576">4576</a><a id="L4577" href="#L4577">4577</a><a id="L4578" href="#L4578">4578</a><a id="L4579" href="#L4579">4579</a><a id="L4580" href="#L4580">4580</a><a id="L4581" href="#L4581">4581</a><a id="L4582" href="#L4582">4582</a><a id="L4583" href="#L4583">4583</a><a id="L4584" href="#L4584">4584</a><a id="L4585" href="#L4585">4585</a><a id="L4586" href="#L4586">4586</a><a id="L4587" href="#L4587">4587</a><a id="L4588" href="#L4588">4588</a><a id="L4589" href="#L4589">4589</a><a id="L4590" href="#L4590">4590</a><a id="L4591" href="#L4591">4591</a><a id="L4592" href="#L4592">4592</a><a id="L4593" href="#L4593">4593</a><a id="L4594" href="#L4594">4594</a><a id="L4595" href="#L4595">4595</a><a id="L4596" href="#L4596">4596</a><a id="L4597" href="#L4597">4597</a><a id="L4598" href="#L4598">4598</a><a id="L4599" href="#L4599">4599</a><a id="L4600" href="#L4600">4600</a><a id="L4601" href="#L4601">4601</a><a id="L4602" href="#L4602">4602</a><a id="L4603" href="#L4603">4603</a><a id="L4604" href="#L4604">4604</a><a id="L4605" href="#L4605">4605</a><a id="L4606" href="#L4606">4606</a><a id="L4607" href="#L4607">4607</a><a id="L4608" href="#L4608">4608</a><a id="L4609" href="#L4609">4609</a><a id="L4610" href="#L4610">4610</a><a id="L4611" href="#L4611">4611</a><a id="L4612" href="#L4612">4612</a><a id="L4613" href="#L4613">4613</a><a id="L4614" href="#L4614">4614</a><a id="L4615" href="#L4615">4615</a><a id="L4616" href="#L4616">4616</a><a id="L4617" href="#L4617">4617</a><a id="L4618" href="#L4618">4618</a><a id="L4619" href="#L4619">4619</a><a id="L4620" href="#L4620">4620</a><a id="L4621" href="#L4621">4621</a><a id="L4622" href="#L4622">4622</a><a id="L4623" href="#L4623">4623</a><a id="L4624" href="#L4624">4624</a><a id="L4625" href="#L4625">4625</a><a id="L4626" href="#L4626">4626</a><a id="L4627" href="#L4627">4627</a><a id="L4628" href="#L4628">4628</a><a id="L4629" href="#L4629">4629</a><a id="L4630" href="#L4630">4630</a><a id="L4631" href="#L4631">4631</a><a id="L4632" href="#L4632">4632</a><a id="L4633" href="#L4633">4633</a><a id="L4634" href="#L4634">4634</a><a id="L4635" href="#L4635">4635</a><a id="L4636" href="#L4636">4636</a><a id="L4637" href="#L4637">4637</a><a id="L4638" href="#L4638">4638</a><a id="L4639" href="#L4639">4639</a><a id="L4640" href="#L4640">4640</a><a id="L4641" href="#L4641">4641</a><a id="L4642" href="#L4642">4642</a><a id="L4643" href="#L4643">4643</a><a id="L4644" href="#L4644">4644</a><a id="L4645" href="#L4645">4645</a><a id="L4646" href="#L4646">4646</a><a id="L4647" href="#L4647">4647</a><a id="L4648" href="#L4648">4648</a><a id="L4649" href="#L4649">4649</a><a id="L4650" href="#L4650">4650</a><a id="L4651" href="#L4651">4651</a><a id="L4652" href="#L4652">4652</a><a id="L4653" href="#L4653">4653</a><a id="L4654" href="#L4654">4654</a><a id="L4655" href="#L4655">4655</a><a id="L4656" href="#L4656">4656</a><a id="L4657" href="#L4657">4657</a><a id="L4658" href="#L4658">4658</a><a id="L4659" href="#L4659">4659</a><a id="L4660" href="#L4660">4660</a><a id="L4661" href="#L4661">4661</a><a id="L4662" href="#L4662">4662</a><a id="L4663" href="#L4663">4663</a><a id="L4664" href="#L4664">4664</a><a id="L4665" href="#L4665">4665</a><a id="L4666" href="#L4666">4666</a><a id="L4667" href="#L4667">4667</a><a id="L4668" href="#L4668">4668</a><a id="L4669" href="#L4669">4669</a><a id="L4670" href="#L4670">4670</a><a id="L4671" href="#L4671">4671</a><a id="L4672" href="#L4672">4672</a><a id="L4673" href="#L4673">4673</a><a id="L4674" href="#L4674">4674</a><a id="L4675" href="#L4675">4675</a><a id="L4676" href="#L4676">4676</a><a id="L4677" href="#L4677">4677</a><a id="L4678" href="#L4678">4678</a><a id="L4679" href="#L4679">4679</a><a id="L4680" href="#L4680">4680</a><a id="L4681" href="#L4681">4681</a><a id="L4682" href="#L4682">4682</a><a id="L4683" href="#L4683">4683</a><a id="L4684" href="#L4684">4684</a><a id="L4685" href="#L4685">4685</a><a id="L4686" href="#L4686">4686</a><a id="L4687" href="#L4687">4687</a><a id="L4688" href="#L4688">4688</a><a id="L4689" href="#L4689">4689</a><a id="L4690" href="#L4690">4690</a><a id="L4691" href="#L4691">4691</a><a id="L4692" href="#L4692">4692</a><a id="L4693" href="#L4693">4693</a><a id="L4694" href="#L4694">4694</a><a id="L4695" href="#L4695">4695</a><a id="L4696" href="#L4696">4696</a><a id="L4697" href="#L4697">4697</a><a id="L4698" href="#L4698">4698</a><a id="L4699" href="#L4699">4699</a><a id="L4700" href="#L4700">4700</a><a id="L4701" href="#L4701">4701</a><a id="L4702" href="#L4702">4702</a><a id="L4703" href="#L4703">4703</a><a id="L4704" href="#L4704">4704</a><a id="L4705" href="#L4705">4705</a><a id="L4706" href="#L4706">4706</a><a id="L4707" href="#L4707">4707</a><a id="L4708" href="#L4708">4708</a><a id="L4709" href="#L4709">4709</a><a id="L4710" href="#L4710">4710</a><a id="L4711" href="#L4711">4711</a><a id="L4712" href="#L4712">4712</a><a id="L4713" href="#L4713">4713</a><a id="L4714" href="#L4714">4714</a><a id="L4715" href="#L4715">4715</a><a id="L4716" href="#L4716">4716</a><a id="L4717" href="#L4717">4717</a><a id="L4718" href="#L4718">4718</a><a id="L4719" href="#L4719">4719</a><a id="L4720" href="#L4720">4720</a><a id="L4721" href="#L4721">4721</a><a id="L4722" href="#L4722">4722</a><a id="L4723" href="#L4723">4723</a><a id="L4724" href="#L4724">4724</a><a id="L4725" href="#L4725">4725</a><a id="L4726" href="#L4726">4726</a><a id="L4727" href="#L4727">4727</a><a id="L4728" href="#L4728">4728</a><a id="L4729" href="#L4729">4729</a><a id="L4730" href="#L4730">4730</a><a id="L4731" href="#L4731">4731</a><a id="L4732" href="#L4732">4732</a><a id="L4733" href="#L4733">4733</a><a id="L4734" href="#L4734">4734</a><a id="L4735" href="#L4735">4735</a><a id="L4736" href="#L4736">4736</a><a id="L4737" href="#L4737">4737</a><a id="L4738" href="#L4738">4738</a><a id="L4739" href="#L4739">4739</a><a id="L4740" href="#L4740">4740</a><a id="L4741" href="#L4741">4741</a><a id="L4742" href="#L4742">4742</a><a id="L4743" href="#L4743">4743</a><a id="L4744" href="#L4744">4744</a><a id="L4745" href="#L4745">4745</a><a id="L4746" href="#L4746">4746</a><a id="L4747" href="#L4747">4747</a><a id="L4748" href="#L4748">4748</a><a id="L4749" href="#L4749">4749</a><a id="L4750" href="#L4750">4750</a><a id="L4751" href="#L4751">4751</a><a id="L4752" href="#L4752">4752</a><a id="L4753" href="#L4753">4753</a><a id="L4754" href="#L4754">4754</a><a id="L4755" href="#L4755">4755</a><a id="L4756" href="#L4756">4756</a><a id="L4757" href="#L4757">4757</a><a id="L4758" href="#L4758">4758</a><a id="L4759" href="#L4759">4759</a><a id="L4760" href="#L4760">4760</a><a id="L4761" href="#L4761">4761</a><a id="L4762" href="#L4762">4762</a><a id="L4763" href="#L4763">4763</a><a id="L4764" href="#L4764">4764</a><a id="L4765" href="#L4765">4765</a><a id="L4766" href="#L4766">4766</a><a id="L4767" href="#L4767">4767</a><a id="L4768" href="#L4768">4768</a><a id="L4769" href="#L4769">4769</a><a id="L4770" href="#L4770">4770</a><a id="L4771" href="#L4771">4771</a><a id="L4772" href="#L4772">4772</a><a id="L4773" href="#L4773">4773</a><a id="L4774" href="#L4774">4774</a><a id="L4775" href="#L4775">4775</a><a id="L4776" href="#L4776">4776</a><a id="L4777" href="#L4777">4777</a><a id="L4778" href="#L4778">4778</a><a id="L4779" href="#L4779">4779</a><a id="L4780" href="#L4780">4780</a><a id="L4781" href="#L4781">4781</a><a id="L4782" href="#L4782">4782</a><a id="L4783" href="#L4783">4783</a><a id="L4784" href="#L4784">4784</a><a id="L4785" href="#L4785">4785</a><a id="L4786" href="#L4786">4786</a><a id="L4787" href="#L4787">4787</a><a id="L4788" href="#L4788">4788</a><a id="L4789" href="#L4789">4789</a><a id="L4790" href="#L4790">4790</a><a id="L4791" href="#L4791">4791</a><a id="L4792" href="#L4792">4792</a><a id="L4793" href="#L4793">4793</a><a id="L4794" href="#L4794">4794</a><a id="L4795" href="#L4795">4795</a><a id="L4796" href="#L4796">4796</a><a id="L4797" href="#L4797">4797</a><a id="L4798" href="#L4798">4798</a><a id="L4799" href="#L4799">4799</a><a id="L4800" href="#L4800">4800</a><a id="L4801" href="#L4801">4801</a><a id="L4802" href="#L4802">4802</a><a id="L4803" href="#L4803">4803</a><a id="L4804" href="#L4804">4804</a><a id="L4805" href="#L4805">4805</a><a id="L4806" href="#L4806">4806</a><a id="L4807" href="#L4807">4807</a><a id="L4808" href="#L4808">4808</a><a id="L4809" href="#L4809">4809</a><a id="L4810" href="#L4810">4810</a><a id="L4811" href="#L4811">4811</a><a id="L4812" href="#L4812">4812</a><a id="L4813" href="#L4813">4813</a><a id="L4814" href="#L4814">4814</a><a id="L4815" href="#L4815">4815</a><a id="L4816" href="#L4816">4816</a><a id="L4817" href="#L4817">4817</a><a id="L4818" href="#L4818">4818</a><a id="L4819" href="#L4819">4819</a><a id="L4820" href="#L4820">4820</a><a id="L4821" href="#L4821">4821</a><a id="L4822" href="#L4822">4822</a><a id="L4823" href="#L4823">4823</a><a id="L4824" href="#L4824">4824</a><a id="L4825" href="#L4825">4825</a><a id="L4826" href="#L4826">4826</a><a id="L4827" href="#L4827">4827</a><a id="L4828" href="#L4828">4828</a><a id="L4829" href="#L4829">4829</a><a id="L4830" href="#L4830">4830</a><a id="L4831" href="#L4831">4831</a><a id="L4832" href="#L4832">4832</a><a id="L4833" href="#L4833">4833</a><a id="L4834" href="#L4834">4834</a><a id="L4835" href="#L4835">4835</a><a id="L4836" href="#L4836">4836</a><a id="L4837" href="#L4837">4837</a><a id="L4838" href="#L4838">4838</a><a id="L4839" href="#L4839">4839</a><a id="L4840" href="#L4840">4840</a><a id="L4841" href="#L4841">4841</a><a id="L4842" href="#L4842">4842</a><a id="L4843" href="#L4843">4843</a><a id="L4844" href="#L4844">4844</a><a id="L4845" href="#L4845">4845</a><a id="L4846" href="#L4846">4846</a><a id="L4847" href="#L4847">4847</a><a id="L4848" href="#L4848">4848</a><a id="L4849" href="#L4849">4849</a><a id="L4850" href="#L4850">4850</a><a id="L4851" href="#L4851">4851</a><a id="L4852" href="#L4852">4852</a><a id="L4853" href="#L4853">4853</a><a id="L4854" href="#L4854">4854</a><a id="L4855" href="#L4855">4855</a><a id="L4856" href="#L4856">4856</a><a id="L4857" href="#L4857">4857</a><a id="L4858" href="#L4858">4858</a><a id="L4859" href="#L4859">4859</a><a id="L4860" href="#L4860">4860</a><a id="L4861" href="#L4861">4861</a><a id="L4862" href="#L4862">4862</a><a id="L4863" href="#L4863">4863</a><a id="L4864" href="#L4864">4864</a><a id="L4865" href="#L4865">4865</a><a id="L4866" href="#L4866">4866</a><a id="L4867" href="#L4867">4867</a><a id="L4868" href="#L4868">4868</a><a id="L4869" href="#L4869">4869</a><a id="L4870" href="#L4870">4870</a><a id="L4871" href="#L4871">4871</a><a id="L4872" href="#L4872">4872</a><a id="L4873" href="#L4873">4873</a><a id="L4874" href="#L4874">4874</a><a id="L4875" href="#L4875">4875</a><a id="L4876" href="#L4876">4876</a><a id="L4877" href="#L4877">4877</a><a id="L4878" href="#L4878">4878</a><a id="L4879" href="#L4879">4879</a><a id="L4880" href="#L4880">4880</a><a id="L4881" href="#L4881">4881</a><a id="L4882" href="#L4882">4882</a><a id="L4883" href="#L4883">4883</a><a id="L4884" href="#L4884">4884</a><a id="L4885" href="#L4885">4885</a><a id="L4886" href="#L4886">4886</a><a id="L4887" href="#L4887">4887</a><a id="L4888" href="#L4888">4888</a><a id="L4889" href="#L4889">4889</a><a id="L4890" href="#L4890">4890</a><a id="L4891" href="#L4891">4891</a><a id="L4892" href="#L4892">4892</a><a id="L4893" href="#L4893">4893</a><a id="L4894" href="#L4894">4894</a><a id="L4895" href="#L4895">4895</a><a id="L4896" href="#L4896">4896</a><a id="L4897" href="#L4897">4897</a><a id="L4898" href="#L4898">4898</a><a id="L4899" href="#L4899">4899</a><a id="L4900" href="#L4900">4900</a><a id="L4901" href="#L4901">4901</a><a id="L4902" href="#L4902">4902</a><a id="L4903" href="#L4903">4903</a><a id="L4904" href="#L4904">4904</a><a id="L4905" href="#L4905">4905</a><a id="L4906" href="#L4906">4906</a><a id="L4907" href="#L4907">4907</a><a id="L4908" href="#L4908">4908</a><a id="L4909" href="#L4909">4909</a><a id="L4910" href="#L4910">4910</a><a id="L4911" href="#L4911">4911</a><a id="L4912" href="#L4912">4912</a><a id="L4913" href="#L4913">4913</a><a id="L4914" href="#L4914">4914</a><a id="L4915" href="#L4915">4915</a><a id="L4916" href="#L4916">4916</a><a id="L4917" href="#L4917">4917</a><a id="L4918" href="#L4918">4918</a><a id="L4919" href="#L4919">4919</a><a id="L4920" href="#L4920">4920</a><a id="L4921" href="#L4921">4921</a><a id="L4922" href="#L4922">4922</a><a id="L4923" href="#L4923">4923</a><a id="L4924" href="#L4924">4924</a><a id="L4925" href="#L4925">4925</a><a id="L4926" href="#L4926">4926</a><a id="L4927" href="#L4927">4927</a><a id="L4928" href="#L4928">4928</a><a id="L4929" href="#L4929">4929</a><a id="L4930" href="#L4930">4930</a><a id="L4931" href="#L4931">4931</a><a id="L4932" href="#L4932">4932</a><a id="L4933" href="#L4933">4933</a><a id="L4934" href="#L4934">4934</a><a id="L4935" href="#L4935">4935</a><a id="L4936" href="#L4936">4936</a><a id="L4937" href="#L4937">4937</a><a id="L4938" href="#L4938">4938</a><a id="L4939" href="#L4939">4939</a><a id="L4940" href="#L4940">4940</a><a id="L4941" href="#L4941">4941</a><a id="L4942" href="#L4942">4942</a><a id="L4943" href="#L4943">4943</a><a id="L4944" href="#L4944">4944</a><a id="L4945" href="#L4945">4945</a><a id="L4946" href="#L4946">4946</a><a id="L4947" href="#L4947">4947</a><a id="L4948" href="#L4948">4948</a><a id="L4949" href="#L4949">4949</a><a id="L4950" href="#L4950">4950</a><a id="L4951" href="#L4951">4951</a><a id="L4952" href="#L4952">4952</a><a id="L4953" href="#L4953">4953</a><a id="L4954" href="#L4954">4954</a><a id="L4955" href="#L4955">4955</a><a id="L4956" href="#L4956">4956</a><a id="L4957" href="#L4957">4957</a><a id="L4958" href="#L4958">4958</a><a id="L4959" href="#L4959">4959</a><a id="L4960" href="#L4960">4960</a><a id="L4961" href="#L4961">4961</a><a id="L4962" href="#L4962">4962</a><a id="L4963" href="#L4963">4963</a><a id="L4964" href="#L4964">4964</a><a id="L4965" href="#L4965">4965</a><a id="L4966" href="#L4966">4966</a><a id="L4967" href="#L4967">4967</a><a id="L4968" href="#L4968">4968</a><a id="L4969" href="#L4969">4969</a><a id="L4970" href="#L4970">4970</a><a id="L4971" href="#L4971">4971</a><a id="L4972" href="#L4972">4972</a><a id="L4973" href="#L4973">4973</a><a id="L4974" href="#L4974">4974</a><a id="L4975" href="#L4975">4975</a><a id="L4976" href="#L4976">4976</a><a id="L4977" href="#L4977">4977</a><a id="L4978" href="#L4978">4978</a><a id="L4979" href="#L4979">4979</a><a id="L4980" href="#L4980">4980</a><a id="L4981" href="#L4981">4981</a><a id="L4982" href="#L4982">4982</a><a id="L4983" href="#L4983">4983</a><a id="L4984" href="#L4984">4984</a><a id="L4985" href="#L4985">4985</a><a id="L4986" href="#L4986">4986</a><a id="L4987" href="#L4987">4987</a><a id="L4988" href="#L4988">4988</a><a id="L4989" href="#L4989">4989</a><a id="L4990" href="#L4990">4990</a><a id="L4991" href="#L4991">4991</a><a id="L4992" href="#L4992">4992</a><a id="L4993" href="#L4993">4993</a><a id="L4994" href="#L4994">4994</a><a id="L4995" href="#L4995">4995</a><a id="L4996" href="#L4996">4996</a><a id="L4997" href="#L4997">4997</a><a id="L4998" href="#L4998">4998</a><a id="L4999" href="#L4999">4999</a><a id="L5000" href="#L5000">5000</a><a id="L5001" href="#L5001">5001</a><a id="L5002" href="#L5002">5002</a><a id="L5003" href="#L5003">5003</a><a id="L5004" href="#L5004">5004</a><a id="L5005" href="#L5005">5005</a><a id="L5006" href="#L5006">5006</a><a id="L5007" href="#L5007">5007</a><a id="L5008" href="#L5008">5008</a><a id="L5009" href="#L5009">5009</a><a id="L5010" href="#L5010">5010</a><a id="L5011" href="#L5011">5011</a><a id="L5012" href="#L5012">5012</a><a id="L5013" href="#L5013">5013</a><a id="L5014" href="#L5014">5014</a><a id="L5015" href="#L5015">5015</a><a id="L5016" href="#L5016">5016</a><a id="L5017" href="#L5017">5017</a><a id="L5018" href="#L5018">5018</a><a id="L5019" href="#L5019">5019</a><a id="L5020" href="#L5020">5020</a><a id="L5021" href="#L5021">5021</a><a id="L5022" href="#L5022">5022</a><a id="L5023" href="#L5023">5023</a><a id="L5024" href="#L5024">5024</a><a id="L5025" href="#L5025">5025</a><a id="L5026" href="#L5026">5026</a><a id="L5027" href="#L5027">5027</a><a id="L5028" href="#L5028">5028</a><a id="L5029" href="#L5029">5029</a><a id="L5030" href="#L5030">5030</a><a id="L5031" href="#L5031">5031</a><a id="L5032" href="#L5032">5032</a><a id="L5033" href="#L5033">5033</a><a id="L5034" href="#L5034">5034</a><a id="L5035" href="#L5035">5035</a><a id="L5036" href="#L5036">5036</a><a id="L5037" href="#L5037">5037</a><a id="L5038" href="#L5038">5038</a><a id="L5039" href="#L5039">5039</a><a id="L5040" href="#L5040">5040</a><a id="L5041" href="#L5041">5041</a><a id="L5042" href="#L5042">5042</a><a id="L5043" href="#L5043">5043</a><a id="L5044" href="#L5044">5044</a><a id="L5045" href="#L5045">5045</a><a id="L5046" href="#L5046">5046</a><a id="L5047" href="#L5047">5047</a><a id="L5048" href="#L5048">5048</a><a id="L5049" href="#L5049">5049</a><a id="L5050" href="#L5050">5050</a><a id="L5051" href="#L5051">5051</a><a id="L5052" href="#L5052">5052</a><a id="L5053" href="#L5053">5053</a><a id="L5054" href="#L5054">5054</a><a id="L5055" href="#L5055">5055</a><a id="L5056" href="#L5056">5056</a><a id="L5057" href="#L5057">5057</a><a id="L5058" href="#L5058">5058</a><a id="L5059" href="#L5059">5059</a><a id="L5060" href="#L5060">5060</a><a id="L5061" href="#L5061">5061</a><a id="L5062" href="#L5062">5062</a><a id="L5063" href="#L5063">5063</a><a id="L5064" href="#L5064">5064</a><a id="L5065" href="#L5065">5065</a><a id="L5066" href="#L5066">5066</a><a id="L5067" href="#L5067">5067</a><a id="L5068" href="#L5068">5068</a><a id="L5069" href="#L5069">5069</a><a id="L5070" href="#L5070">5070</a><a id="L5071" href="#L5071">5071</a><a id="L5072" href="#L5072">5072</a><a id="L5073" href="#L5073">5073</a><a id="L5074" href="#L5074">5074</a><a id="L5075" href="#L5075">5075</a><a id="L5076" href="#L5076">5076</a><a id="L5077" href="#L5077">5077</a><a id="L5078" href="#L5078">5078</a><a id="L5079" href="#L5079">5079</a><a id="L5080" href="#L5080">5080</a><a id="L5081" href="#L5081">5081</a><a id="L5082" href="#L5082">5082</a><a id="L5083" href="#L5083">5083</a><a id="L5084" href="#L5084">5084</a><a id="L5085" href="#L5085">5085</a><a id="L5086" href="#L5086">5086</a><a id="L5087" href="#L5087">5087</a><a id="L5088" href="#L5088">5088</a><a id="L5089" href="#L5089">5089</a><a id="L5090" href="#L5090">5090</a><a id="L5091" href="#L5091">5091</a><a id="L5092" href="#L5092">5092</a><a id="L5093" href="#L5093">5093</a><a id="L5094" href="#L5094">5094</a><a id="L5095" href="#L5095">5095</a><a id="L5096" href="#L5096">5096</a><a id="L5097" href="#L5097">5097</a><a id="L5098" href="#L5098">5098</a><a id="L5099" href="#L5099">5099</a><a id="L5100" href="#L5100">5100</a><a id="L5101" href="#L5101">5101</a><a id="L5102" href="#L5102">5102</a><a id="L5103" href="#L5103">5103</a><a id="L5104" href="#L5104">5104</a><a id="L5105" href="#L5105">5105</a><a id="L5106" href="#L5106">5106</a><a id="L5107" href="#L5107">5107</a><a id="L5108" href="#L5108">5108</a><a id="L5109" href="#L5109">5109</a><a id="L5110" href="#L5110">5110</a><a id="L5111" href="#L5111">5111</a><a id="L5112" href="#L5112">5112</a><a id="L5113" href="#L5113">5113</a><a id="L5114" href="#L5114">5114</a><a id="L5115" href="#L5115">5115</a><a id="L5116" href="#L5116">5116</a><a id="L5117" href="#L5117">5117</a><a id="L5118" href="#L5118">5118</a><a id="L5119" href="#L5119">5119</a><a id="L5120" href="#L5120">5120</a><a id="L5121" href="#L5121">5121</a><a id="L5122" href="#L5122">5122</a><a id="L5123" href="#L5123">5123</a><a id="L5124" href="#L5124">5124</a><a id="L5125" href="#L5125">5125</a><a id="L5126" href="#L5126">5126</a><a id="L5127" href="#L5127">5127</a><a id="L5128" href="#L5128">5128</a><a id="L5129" href="#L5129">5129</a><a id="L5130" href="#L5130">5130</a><a id="L5131" href="#L5131">5131</a><a id="L5132" href="#L5132">5132</a><a id="L5133" href="#L5133">5133</a><a id="L5134" href="#L5134">5134</a><a id="L5135" href="#L5135">5135</a><a id="L5136" href="#L5136">5136</a><a id="L5137" href="#L5137">5137</a><a id="L5138" href="#L5138">5138</a><a id="L5139" href="#L5139">5139</a><a id="L5140" href="#L5140">5140</a><a id="L5141" href="#L5141">5141</a><a id="L5142" href="#L5142">5142</a><a id="L5143" href="#L5143">5143</a><a id="L5144" href="#L5144">5144</a><a id="L5145" href="#L5145">5145</a><a id="L5146" href="#L5146">5146</a><a id="L5147" href="#L5147">5147</a><a id="L5148" href="#L5148">5148</a><a id="L5149" href="#L5149">5149</a><a id="L5150" href="#L5150">5150</a><a id="L5151" href="#L5151">5151</a><a id="L5152" href="#L5152">5152</a><a id="L5153" href="#L5153">5153</a><a id="L5154" href="#L5154">5154</a><a id="L5155" href="#L5155">5155</a><a id="L5156" href="#L5156">5156</a><a id="L5157" href="#L5157">5157</a><a id="L5158" href="#L5158">5158</a><a id="L5159" href="#L5159">5159</a><a id="L5160" href="#L5160">5160</a><a id="L5161" href="#L5161">5161</a><a id="L5162" href="#L5162">5162</a><a id="L5163" href="#L5163">5163</a><a id="L5164" href="#L5164">5164</a><a id="L5165" href="#L5165">5165</a><a id="L5166" href="#L5166">5166</a><a id="L5167" href="#L5167">5167</a><a id="L5168" href="#L5168">5168</a><a id="L5169" href="#L5169">5169</a><a id="L5170" href="#L5170">5170</a><a id="L5171" href="#L5171">5171</a><a id="L5172" href="#L5172">5172</a><a id="L5173" href="#L5173">5173</a><a id="L5174" href="#L5174">5174</a><a id="L5175" href="#L5175">5175</a><a id="L5176" href="#L5176">5176</a><a id="L5177" href="#L5177">5177</a><a id="L5178" href="#L5178">5178</a><a id="L5179" href="#L5179">5179</a><a id="L5180" href="#L5180">5180</a><a id="L5181" href="#L5181">5181</a><a id="L5182" href="#L5182">5182</a><a id="L5183" href="#L5183">5183</a><a id="L5184" href="#L5184">5184</a><a id="L5185" href="#L5185">5185</a><a id="L5186" href="#L5186">5186</a><a id="L5187" href="#L5187">5187</a><a id="L5188" href="#L5188">5188</a><a id="L5189" href="#L5189">5189</a><a id="L5190" href="#L5190">5190</a><a id="L5191" href="#L5191">5191</a><a id="L5192" href="#L5192">5192</a><a id="L5193" href="#L5193">5193</a><a id="L5194" href="#L5194">5194</a><a id="L5195" href="#L5195">5195</a><a id="L5196" href="#L5196">5196</a><a id="L5197" href="#L5197">5197</a><a id="L5198" href="#L5198">5198</a><a id="L5199" href="#L5199">5199</a><a id="L5200" href="#L5200">5200</a><a id="L5201" href="#L5201">5201</a><a id="L5202" href="#L5202">5202</a><a id="L5203" href="#L5203">5203</a><a id="L5204" href="#L5204">5204</a><a id="L5205" href="#L5205">5205</a><a id="L5206" href="#L5206">5206</a><a id="L5207" href="#L5207">5207</a><a id="L5208" href="#L5208">5208</a><a id="L5209" href="#L5209">5209</a><a id="L5210" href="#L5210">5210</a><a id="L5211" href="#L5211">5211</a><a id="L5212" href="#L5212">5212</a><a id="L5213" href="#L5213">5213</a><a id="L5214" href="#L5214">5214</a><a id="L5215" href="#L5215">5215</a><a id="L5216" href="#L5216">5216</a><a id="L5217" href="#L5217">5217</a><a id="L5218" href="#L5218">5218</a><a id="L5219" href="#L5219">5219</a><a id="L5220" href="#L5220">5220</a><a id="L5221" href="#L5221">5221</a><a id="L5222" href="#L5222">5222</a><a id="L5223" href="#L5223">5223</a><a id="L5224" href="#L5224">5224</a><a id="L5225" href="#L5225">5225</a><a id="L5226" href="#L5226">5226</a><a id="L5227" href="#L5227">5227</a><a id="L5228" href="#L5228">5228</a><a id="L5229" href="#L5229">5229</a><a id="L5230" href="#L5230">5230</a><a id="L5231" href="#L5231">5231</a><a id="L5232" href="#L5232">5232</a><a id="L5233" href="#L5233">5233</a><a id="L5234" href="#L5234">5234</a><a id="L5235" href="#L5235">5235</a><a id="L5236" href="#L5236">5236</a><a id="L5237" href="#L5237">5237</a><a id="L5238" href="#L5238">5238</a><a id="L5239" href="#L5239">5239</a><a id="L5240" href="#L5240">5240</a><a id="L5241" href="#L5241">5241</a><a id="L5242" href="#L5242">5242</a><a id="L5243" href="#L5243">5243</a><a id="L5244" href="#L5244">5244</a><a id="L5245" href="#L5245">5245</a><a id="L5246" href="#L5246">5246</a><a id="L5247" href="#L5247">5247</a><a id="L5248" href="#L5248">5248</a><a id="L5249" href="#L5249">5249</a><a id="L5250" href="#L5250">5250</a><a id="L5251" href="#L5251">5251</a><a id="L5252" href="#L5252">5252</a><a id="L5253" href="#L5253">5253</a><a id="L5254" href="#L5254">5254</a><a id="L5255" href="#L5255">5255</a><a id="L5256" href="#L5256">5256</a><a id="L5257" href="#L5257">5257</a><a id="L5258" href="#L5258">5258</a><a id="L5259" href="#L5259">5259</a><a id="L5260" href="#L5260">5260</a><a id="L5261" href="#L5261">5261</a><a id="L5262" href="#L5262">5262</a><a id="L5263" href="#L5263">5263</a><a id="L5264" href="#L5264">5264</a><a id="L5265" href="#L5265">5265</a><a id="L5266" href="#L5266">5266</a><a id="L5267" href="#L5267">5267</a><a id="L5268" href="#L5268">5268</a><a id="L5269" href="#L5269">5269</a><a id="L5270" href="#L5270">5270</a><a id="L5271" href="#L5271">5271</a><a id="L5272" href="#L5272">5272</a><a id="L5273" href="#L5273">5273</a><a id="L5274" href="#L5274">5274</a><a id="L5275" href="#L5275">5275</a><a id="L5276" href="#L5276">5276</a><a id="L5277" href="#L5277">5277</a><a id="L5278" href="#L5278">5278</a><a id="L5279" href="#L5279">5279</a><a id="L5280" href="#L5280">5280</a><a id="L5281" href="#L5281">5281</a><a id="L5282" href="#L5282">5282</a><a id="L5283" href="#L5283">5283</a><a id="L5284" href="#L5284">5284</a><a id="L5285" href="#L5285">5285</a><a id="L5286" href="#L5286">5286</a><a id="L5287" href="#L5287">5287</a><a id="L5288" href="#L5288">5288</a><a id="L5289" href="#L5289">5289</a><a id="L5290" href="#L5290">5290</a><a id="L5291" href="#L5291">5291</a><a id="L5292" href="#L5292">5292</a><a id="L5293" href="#L5293">5293</a><a id="L5294" href="#L5294">5294</a><a id="L5295" href="#L5295">5295</a><a id="L5296" href="#L5296">5296</a><a id="L5297" href="#L5297">5297</a><a id="L5298" href="#L5298">5298</a><a id="L5299" href="#L5299">5299</a><a id="L5300" href="#L5300">5300</a><a id="L5301" href="#L5301">5301</a><a id="L5302" href="#L5302">5302</a><a id="L5303" href="#L5303">5303</a><a id="L5304" href="#L5304">5304</a><a id="L5305" href="#L5305">5305</a><a id="L5306" href="#L5306">5306</a><a id="L5307" href="#L5307">5307</a><a id="L5308" href="#L5308">5308</a><a id="L5309" href="#L5309">5309</a><a id="L5310" href="#L5310">5310</a><a id="L5311" href="#L5311">5311</a><a id="L5312" href="#L5312">5312</a><a id="L5313" href="#L5313">5313</a><a id="L5314" href="#L5314">5314</a><a id="L5315" href="#L5315">5315</a><a id="L5316" href="#L5316">5316</a><a id="L5317" href="#L5317">5317</a><a id="L5318" href="#L5318">5318</a><a id="L5319" href="#L5319">5319</a><a id="L5320" href="#L5320">5320</a><a id="L5321" href="#L5321">5321</a><a id="L5322" href="#L5322">5322</a><a id="L5323" href="#L5323">5323</a><a id="L5324" href="#L5324">5324</a><a id="L5325" href="#L5325">5325</a><a id="L5326" href="#L5326">5326</a><a id="L5327" href="#L5327">5327</a><a id="L5328" href="#L5328">5328</a><a id="L5329" href="#L5329">5329</a><a id="L5330" href="#L5330">5330</a><a id="L5331" href="#L5331">5331</a><a id="L5332" href="#L5332">5332</a><a id="L5333" href="#L5333">5333</a><a id="L5334" href="#L5334">5334</a><a id="L5335" href="#L5335">5335</a><a id="L5336" href="#L5336">5336</a><a id="L5337" href="#L5337">5337</a><a id="L5338" href="#L5338">5338</a><a id="L5339" href="#L5339">5339</a><a id="L5340" href="#L5340">5340</a><a id="L5341" href="#L5341">5341</a><a id="L5342" href="#L5342">5342</a><a id="L5343" href="#L5343">5343</a><a id="L5344" href="#L5344">5344</a><a id="L5345" href="#L5345">5345</a><a id="L5346" href="#L5346">5346</a><a id="L5347" href="#L5347">5347</a><a id="L5348" href="#L5348">5348</a><a id="L5349" href="#L5349">5349</a><a id="L5350" href="#L5350">5350</a><a id="L5351" href="#L5351">5351</a><a id="L5352" href="#L5352">5352</a><a id="L5353" href="#L5353">5353</a><a id="L5354" href="#L5354">5354</a><a id="L5355" href="#L5355">5355</a><a id="L5356" href="#L5356">5356</a><a id="L5357" href="#L5357">5357</a><a id="L5358" href="#L5358">5358</a><a id="L5359" href="#L5359">5359</a><a id="L5360" href="#L5360">5360</a><a id="L5361" href="#L5361">5361</a><a id="L5362" href="#L5362">5362</a><a id="L5363" href="#L5363">5363</a><a id="L5364" href="#L5364">5364</a><a id="L5365" href="#L5365">5365</a><a id="L5366" href="#L5366">5366</a><a id="L5367" href="#L5367">5367</a><a id="L5368" href="#L5368">5368</a><a id="L5369" href="#L5369">5369</a><a id="L5370" href="#L5370">5370</a><a id="L5371" href="#L5371">5371</a><a id="L5372" href="#L5372">5372</a><a id="L5373" href="#L5373">5373</a><a id="L5374" href="#L5374">5374</a><a id="L5375" href="#L5375">5375</a><a id="L5376" href="#L5376">5376</a><a id="L5377" href="#L5377">5377</a><a id="L5378" href="#L5378">5378</a><a id="L5379" href="#L5379">5379</a><a id="L5380" href="#L5380">5380</a><a id="L5381" href="#L5381">5381</a><a id="L5382" href="#L5382">5382</a><a id="L5383" href="#L5383">5383</a><a id="L5384" href="#L5384">5384</a><a id="L5385" href="#L5385">5385</a><a id="L5386" href="#L5386">5386</a><a id="L5387" href="#L5387">5387</a><a id="L5388" href="#L5388">5388</a><a id="L5389" href="#L5389">5389</a><a id="L5390" href="#L5390">5390</a><a id="L5391" href="#L5391">5391</a><a id="L5392" href="#L5392">5392</a><a id="L5393" href="#L5393">5393</a><a id="L5394" href="#L5394">5394</a><a id="L5395" href="#L5395">5395</a><a id="L5396" href="#L5396">5396</a><a id="L5397" href="#L5397">5397</a><a id="L5398" href="#L5398">5398</a><a id="L5399" href="#L5399">5399</a><a id="L5400" href="#L5400">5400</a><a id="L5401" href="#L5401">5401</a><a id="L5402" href="#L5402">5402</a><a id="L5403" href="#L5403">5403</a><a id="L5404" href="#L5404">5404</a><a id="L5405" href="#L5405">5405</a><a id="L5406" href="#L5406">5406</a><a id="L5407" href="#L5407">5407</a><a id="L5408" href="#L5408">5408</a><a id="L5409" href="#L5409">5409</a><a id="L5410" href="#L5410">5410</a><a id="L5411" href="#L5411">5411</a><a id="L5412" href="#L5412">5412</a><a id="L5413" href="#L5413">5413</a><a id="L5414" href="#L5414">5414</a><a id="L5415" href="#L5415">5415</a><a id="L5416" href="#L5416">5416</a><a id="L5417" href="#L5417">5417</a><a id="L5418" href="#L5418">5418</a><a id="L5419" href="#L5419">5419</a><a id="L5420" href="#L5420">5420</a><a id="L5421" href="#L5421">5421</a><a id="L5422" href="#L5422">5422</a><a id="L5423" href="#L5423">5423</a><a id="L5424" href="#L5424">5424</a><a id="L5425" href="#L5425">5425</a><a id="L5426" href="#L5426">5426</a><a id="L5427" href="#L5427">5427</a><a id="L5428" href="#L5428">5428</a><a id="L5429" href="#L5429">5429</a><a id="L5430" href="#L5430">5430</a><a id="L5431" href="#L5431">5431</a><a id="L5432" href="#L5432">5432</a><a id="L5433" href="#L5433">5433</a><a id="L5434" href="#L5434">5434</a><a id="L5435" href="#L5435">5435</a><a id="L5436" href="#L5436">5436</a><a id="L5437" href="#L5437">5437</a><a id="L5438" href="#L5438">5438</a><a id="L5439" href="#L5439">5439</a><a id="L5440" href="#L5440">5440</a><a id="L5441" href="#L5441">5441</a><a id="L5442" href="#L5442">5442</a><a id="L5443" href="#L5443">5443</a><a id="L5444" href="#L5444">5444</a><a id="L5445" href="#L5445">5445</a><a id="L5446" href="#L5446">5446</a><a id="L5447" href="#L5447">5447</a><a id="L5448" href="#L5448">5448</a><a id="L5449" href="#L5449">5449</a><a id="L5450" href="#L5450">5450</a><a id="L5451" href="#L5451">5451</a><a id="L5452" href="#L5452">5452</a><a id="L5453" href="#L5453">5453</a><a id="L5454" href="#L5454">5454</a><a id="L5455" href="#L5455">5455</a><a id="L5456" href="#L5456">5456</a><a id="L5457" href="#L5457">5457</a><a id="L5458" href="#L5458">5458</a><a id="L5459" href="#L5459">5459</a><a id="L5460" href="#L5460">5460</a><a id="L5461" href="#L5461">5461</a><a id="L5462" href="#L5462">5462</a><a id="L5463" href="#L5463">5463</a><a id="L5464" href="#L5464">5464</a><a id="L5465" href="#L5465">5465</a><a id="L5466" href="#L5466">5466</a><a id="L5467" href="#L5467">5467</a><a id="L5468" href="#L5468">5468</a><a id="L5469" href="#L5469">5469</a><a id="L5470" href="#L5470">5470</a><a id="L5471" href="#L5471">5471</a><a id="L5472" href="#L5472">5472</a><a id="L5473" href="#L5473">5473</a><a id="L5474" href="#L5474">5474</a><a id="L5475" href="#L5475">5475</a><a id="L5476" href="#L5476">5476</a><a id="L5477" href="#L5477">5477</a><a id="L5478" href="#L5478">5478</a><a id="L5479" href="#L5479">5479</a><a id="L5480" href="#L5480">5480</a><a id="L5481" href="#L5481">5481</a><a id="L5482" href="#L5482">5482</a><a id="L5483" href="#L5483">5483</a><a id="L5484" href="#L5484">5484</a><a id="L5485" href="#L5485">5485</a><a id="L5486" href="#L5486">5486</a><a id="L5487" href="#L5487">5487</a><a id="L5488" href="#L5488">5488</a><a id="L5489" href="#L5489">5489</a><a id="L5490" href="#L5490">5490</a><a id="L5491" href="#L5491">5491</a><a id="L5492" href="#L5492">5492</a><a id="L5493" href="#L5493">5493</a><a id="L5494" href="#L5494">5494</a><a id="L5495" href="#L5495">5495</a><a id="L5496" href="#L5496">5496</a><a id="L5497" href="#L5497">5497</a><a id="L5498" href="#L5498">5498</a><a id="L5499" href="#L5499">5499</a><a id="L5500" href="#L5500">5500</a><a id="L5501" href="#L5501">5501</a><a id="L5502" href="#L5502">5502</a><a id="L5503" href="#L5503">5503</a><a id="L5504" href="#L5504">5504</a><a id="L5505" href="#L5505">5505</a><a id="L5506" href="#L5506">5506</a><a id="L5507" href="#L5507">5507</a><a id="L5508" href="#L5508">5508</a><a id="L5509" href="#L5509">5509</a><a id="L5510" href="#L5510">5510</a><a id="L5511" href="#L5511">5511</a><a id="L5512" href="#L5512">5512</a><a id="L5513" href="#L5513">5513</a><a id="L5514" href="#L5514">5514</a><a id="L5515" href="#L5515">5515</a><a id="L5516" href="#L5516">5516</a><a id="L5517" href="#L5517">5517</a><a id="L5518" href="#L5518">5518</a><a id="L5519" href="#L5519">5519</a><a id="L5520" href="#L5520">5520</a><a id="L5521" href="#L5521">5521</a><a id="L5522" href="#L5522">5522</a><a id="L5523" href="#L5523">5523</a><a id="L5524" href="#L5524">5524</a><a id="L5525" href="#L5525">5525</a><a id="L5526" href="#L5526">5526</a><a id="L5527" href="#L5527">5527</a><a id="L5528" href="#L5528">5528</a><a id="L5529" href="#L5529">5529</a><a id="L5530" href="#L5530">5530</a><a id="L5531" href="#L5531">5531</a><a id="L5532" href="#L5532">5532</a><a id="L5533" href="#L5533">5533</a><a id="L5534" href="#L5534">5534</a><a id="L5535" href="#L5535">5535</a><a id="L5536" href="#L5536">5536</a><a id="L5537" href="#L5537">5537</a><a id="L5538" href="#L5538">5538</a><a id="L5539" href="#L5539">5539</a><a id="L5540" href="#L5540">5540</a><a id="L5541" href="#L5541">5541</a><a id="L5542" href="#L5542">5542</a><a id="L5543" href="#L5543">5543</a><a id="L5544" href="#L5544">5544</a><a id="L5545" href="#L5545">5545</a><a id="L5546" href="#L5546">5546</a><a id="L5547" href="#L5547">5547</a><a id="L5548" href="#L5548">5548</a><a id="L5549" href="#L5549">5549</a><a id="L5550" href="#L5550">5550</a><a id="L5551" href="#L5551">5551</a><a id="L5552" href="#L5552">5552</a><a id="L5553" href="#L5553">5553</a><a id="L5554" href="#L5554">5554</a><a id="L5555" href="#L5555">5555</a><a id="L5556" href="#L5556">5556</a><a id="L5557" href="#L5557">5557</a><a id="L5558" href="#L5558">5558</a><a id="L5559" href="#L5559">5559</a><a id="L5560" href="#L5560">5560</a><a id="L5561" href="#L5561">5561</a><a id="L5562" href="#L5562">5562</a><a id="L5563" href="#L5563">5563</a><a id="L5564" href="#L5564">5564</a><a id="L5565" href="#L5565">5565</a><a id="L5566" href="#L5566">5566</a><a id="L5567" href="#L5567">5567</a><a id="L5568" href="#L5568">5568</a><a id="L5569" href="#L5569">5569</a><a id="L5570" href="#L5570">5570</a><a id="L5571" href="#L5571">5571</a><a id="L5572" href="#L5572">5572</a><a id="L5573" href="#L5573">5573</a><a id="L5574" href="#L5574">5574</a><a id="L5575" href="#L5575">5575</a><a id="L5576" href="#L5576">5576</a><a id="L5577" href="#L5577">5577</a><a id="L5578" href="#L5578">5578</a><a id="L5579" href="#L5579">5579</a><a id="L5580" href="#L5580">5580</a><a id="L5581" href="#L5581">5581</a><a id="L5582" href="#L5582">5582</a><a id="L5583" href="#L5583">5583</a><a id="L5584" href="#L5584">5584</a><a id="L5585" href="#L5585">5585</a><a id="L5586" href="#L5586">5586</a><a id="L5587" href="#L5587">5587</a><a id="L5588" href="#L5588">5588</a><a id="L5589" href="#L5589">5589</a><a id="L5590" href="#L5590">5590</a><a id="L5591" href="#L5591">5591</a><a id="L5592" href="#L5592">5592</a><a id="L5593" href="#L5593">5593</a><a id="L5594" href="#L5594">5594</a><a id="L5595" href="#L5595">5595</a><a id="L5596" href="#L5596">5596</a><a id="L5597" href="#L5597">5597</a><a id="L5598" href="#L5598">5598</a><a id="L5599" href="#L5599">5599</a><a id="L5600" href="#L5600">5600</a><a id="L5601" href="#L5601">5601</a><a id="L5602" href="#L5602">5602</a><a id="L5603" href="#L5603">5603</a><a id="L5604" href="#L5604">5604</a><a id="L5605" href="#L5605">5605</a><a id="L5606" href="#L5606">5606</a><a id="L5607" href="#L5607">5607</a><a id="L5608" href="#L5608">5608</a><a id="L5609" href="#L5609">5609</a><a id="L5610" href="#L5610">5610</a><a id="L5611" href="#L5611">5611</a><a id="L5612" href="#L5612">5612</a><a id="L5613" href="#L5613">5613</a><a id="L5614" href="#L5614">5614</a><a id="L5615" href="#L5615">5615</a><a id="L5616" href="#L5616">5616</a><a id="L5617" href="#L5617">5617</a><a id="L5618" href="#L5618">5618</a><a id="L5619" href="#L5619">5619</a><a id="L5620" href="#L5620">5620</a><a id="L5621" href="#L5621">5621</a><a id="L5622" href="#L5622">5622</a><a id="L5623" href="#L5623">5623</a><a id="L5624" href="#L5624">5624</a><a id="L5625" href="#L5625">5625</a><a id="L5626" href="#L5626">5626</a><a id="L5627" href="#L5627">5627</a><a id="L5628" href="#L5628">5628</a><a id="L5629" href="#L5629">5629</a><a id="L5630" href="#L5630">5630</a><a id="L5631" href="#L5631">5631</a><a id="L5632" href="#L5632">5632</a><a id="L5633" href="#L5633">5633</a><a id="L5634" href="#L5634">5634</a><a id="L5635" href="#L5635">5635</a><a id="L5636" href="#L5636">5636</a><a id="L5637" href="#L5637">5637</a><a id="L5638" href="#L5638">5638</a><a id="L5639" href="#L5639">5639</a><a id="L5640" href="#L5640">5640</a><a id="L5641" href="#L5641">5641</a><a id="L5642" href="#L5642">5642</a><a id="L5643" href="#L5643">5643</a><a id="L5644" href="#L5644">5644</a><a id="L5645" href="#L5645">5645</a><a id="L5646" href="#L5646">5646</a><a id="L5647" href="#L5647">5647</a><a id="L5648" href="#L5648">5648</a><a id="L5649" href="#L5649">5649</a><a id="L5650" href="#L5650">5650</a><a id="L5651" href="#L5651">5651</a><a id="L5652" href="#L5652">5652</a><a id="L5653" href="#L5653">5653</a><a id="L5654" href="#L5654">5654</a><a id="L5655" href="#L5655">5655</a><a id="L5656" href="#L5656">5656</a><a id="L5657" href="#L5657">5657</a><a id="L5658" href="#L5658">5658</a><a id="L5659" href="#L5659">5659</a><a id="L5660" href="#L5660">5660</a><a id="L5661" href="#L5661">5661</a><a id="L5662" href="#L5662">5662</a><a id="L5663" href="#L5663">5663</a><a id="L5664" href="#L5664">5664</a><a id="L5665" href="#L5665">5665</a><a id="L5666" href="#L5666">5666</a><a id="L5667" href="#L5667">5667</a><a id="L5668" href="#L5668">5668</a><a id="L5669" href="#L5669">5669</a><a id="L5670" href="#L5670">5670</a><a id="L5671" href="#L5671">5671</a><a id="L5672" href="#L5672">5672</a><a id="L5673" href="#L5673">5673</a><a id="L5674" href="#L5674">5674</a><a id="L5675" href="#L5675">5675</a><a id="L5676" href="#L5676">5676</a><a id="L5677" href="#L5677">5677</a><a id="L5678" href="#L5678">5678</a><a id="L5679" href="#L5679">5679</a><a id="L5680" href="#L5680">5680</a><a id="L5681" href="#L5681">5681</a><a id="L5682" href="#L5682">5682</a><a id="L5683" href="#L5683">5683</a><a id="L5684" href="#L5684">5684</a><a id="L5685" href="#L5685">5685</a><a id="L5686" href="#L5686">5686</a><a id="L5687" href="#L5687">5687</a><a id="L5688" href="#L5688">5688</a><a id="L5689" href="#L5689">5689</a><a id="L5690" href="#L5690">5690</a><a id="L5691" href="#L5691">5691</a><a id="L5692" href="#L5692">5692</a><a id="L5693" href="#L5693">5693</a><a id="L5694" href="#L5694">5694</a><a id="L5695" href="#L5695">5695</a><a id="L5696" href="#L5696">5696</a><a id="L5697" href="#L5697">5697</a><a id="L5698" href="#L5698">5698</a><a id="L5699" href="#L5699">5699</a><a id="L5700" href="#L5700">5700</a><a id="L5701" href="#L5701">5701</a><a id="L5702" href="#L5702">5702</a><a id="L5703" href="#L5703">5703</a><a id="L5704" href="#L5704">5704</a><a id="L5705" href="#L5705">5705</a><a id="L5706" href="#L5706">5706</a><a id="L5707" href="#L5707">5707</a><a id="L5708" href="#L5708">5708</a><a id="L5709" href="#L5709">5709</a><a id="L5710" href="#L5710">5710</a><a id="L5711" href="#L5711">5711</a><a id="L5712" href="#L5712">5712</a><a id="L5713" href="#L5713">5713</a><a id="L5714" href="#L5714">5714</a><a id="L5715" href="#L5715">5715</a><a id="L5716" href="#L5716">5716</a><a id="L5717" href="#L5717">5717</a><a id="L5718" href="#L5718">5718</a><a id="L5719" href="#L5719">5719</a><a id="L5720" href="#L5720">5720</a><a id="L5721" href="#L5721">5721</a><a id="L5722" href="#L5722">5722</a><a id="L5723" href="#L5723">5723</a><a id="L5724" href="#L5724">5724</a><a id="L5725" href="#L5725">5725</a><a id="L5726" href="#L5726">5726</a><a id="L5727" href="#L5727">5727</a><a id="L5728" href="#L5728">5728</a><a id="L5729" href="#L5729">5729</a><a id="L5730" href="#L5730">5730</a><a id="L5731" href="#L5731">5731</a><a id="L5732" href="#L5732">5732</a><a id="L5733" href="#L5733">5733</a><a id="L5734" href="#L5734">5734</a><a id="L5735" href="#L5735">5735</a><a id="L5736" href="#L5736">5736</a><a id="L5737" href="#L5737">5737</a><a id="L5738" href="#L5738">5738</a><a id="L5739" href="#L5739">5739</a><a id="L5740" href="#L5740">5740</a><a id="L5741" href="#L5741">5741</a><a id="L5742" href="#L5742">5742</a><a id="L5743" href="#L5743">5743</a><a id="L5744" href="#L5744">5744</a><a id="L5745" href="#L5745">5745</a><a id="L5746" href="#L5746">5746</a><a id="L5747" href="#L5747">5747</a><a id="L5748" href="#L5748">5748</a><a id="L5749" href="#L5749">5749</a><a id="L5750" href="#L5750">5750</a><a id="L5751" href="#L5751">5751</a><a id="L5752" href="#L5752">5752</a><a id="L5753" href="#L5753">5753</a><a id="L5754" href="#L5754">5754</a><a id="L5755" href="#L5755">5755</a><a id="L5756" href="#L5756">5756</a><a id="L5757" href="#L5757">5757</a><a id="L5758" href="#L5758">5758</a><a id="L5759" href="#L5759">5759</a><a id="L5760" href="#L5760">5760</a><a id="L5761" href="#L5761">5761</a><a id="L5762" href="#L5762">5762</a><a id="L5763" href="#L5763">5763</a><a id="L5764" href="#L5764">5764</a><a id="L5765" href="#L5765">5765</a><a id="L5766" href="#L5766">5766</a><a id="L5767" href="#L5767">5767</a><a id="L5768" href="#L5768">5768</a><a id="L5769" href="#L5769">5769</a><a id="L5770" href="#L5770">5770</a><a id="L5771" href="#L5771">5771</a><a id="L5772" href="#L5772">5772</a><a id="L5773" href="#L5773">5773</a><a id="L5774" href="#L5774">5774</a><a id="L5775" href="#L5775">5775</a><a id="L5776" href="#L5776">5776</a><a id="L5777" href="#L5777">5777</a><a id="L5778" href="#L5778">5778</a><a id="L5779" href="#L5779">5779</a><a id="L5780" href="#L5780">5780</a><a id="L5781" href="#L5781">5781</a><a id="L5782" href="#L5782">5782</a><a id="L5783" href="#L5783">5783</a><a id="L5784" href="#L5784">5784</a><a id="L5785" href="#L5785">5785</a><a id="L5786" href="#L5786">5786</a><a id="L5787" href="#L5787">5787</a><a id="L5788" href="#L5788">5788</a><a id="L5789" href="#L5789">5789</a><a id="L5790" href="#L5790">5790</a><a id="L5791" href="#L5791">5791</a><a id="L5792" href="#L5792">5792</a><a id="L5793" href="#L5793">5793</a><a id="L5794" href="#L5794">5794</a><a id="L5795" href="#L5795">5795</a><a id="L5796" href="#L5796">5796</a><a id="L5797" href="#L5797">5797</a><a id="L5798" href="#L5798">5798</a><a id="L5799" href="#L5799">5799</a><a id="L5800" href="#L5800">5800</a><a id="L5801" href="#L5801">5801</a><a id="L5802" href="#L5802">5802</a><a id="L5803" href="#L5803">5803</a><a id="L5804" href="#L5804">5804</a><a id="L5805" href="#L5805">5805</a><a id="L5806" href="#L5806">5806</a><a id="L5807" href="#L5807">5807</a><a id="L5808" href="#L5808">5808</a><a id="L5809" href="#L5809">5809</a><a id="L5810" href="#L5810">5810</a><a id="L5811" href="#L5811">5811</a><a id="L5812" href="#L5812">5812</a><a id="L5813" href="#L5813">5813</a><a id="L5814" href="#L5814">5814</a><a id="L5815" href="#L5815">5815</a><a id="L5816" href="#L5816">5816</a><a id="L5817" href="#L5817">5817</a><a id="L5818" href="#L5818">5818</a><a id="L5819" href="#L5819">5819</a><a id="L5820" href="#L5820">5820</a><a id="L5821" href="#L5821">5821</a><a id="L5822" href="#L5822">5822</a><a id="L5823" href="#L5823">5823</a><a id="L5824" href="#L5824">5824</a><a id="L5825" href="#L5825">5825</a><a id="L5826" href="#L5826">5826</a><a id="L5827" href="#L5827">5827</a><a id="L5828" href="#L5828">5828</a><a id="L5829" href="#L5829">5829</a><a id="L5830" href="#L5830">5830</a><a id="L5831" href="#L5831">5831</a><a id="L5832" href="#L5832">5832</a><a id="L5833" href="#L5833">5833</a><a id="L5834" href="#L5834">5834</a><a id="L5835" href="#L5835">5835</a><a id="L5836" href="#L5836">5836</a><a id="L5837" href="#L5837">5837</a><a id="L5838" href="#L5838">5838</a><a id="L5839" href="#L5839">5839</a><a id="L5840" href="#L5840">5840</a><a id="L5841" href="#L5841">5841</a><a id="L5842" href="#L5842">5842</a><a id="L5843" href="#L5843">5843</a><a id="L5844" href="#L5844">5844</a><a id="L5845" href="#L5845">5845</a><a id="L5846" href="#L5846">5846</a><a id="L5847" href="#L5847">5847</a><a id="L5848" href="#L5848">5848</a><a id="L5849" href="#L5849">5849</a><a id="L5850" href="#L5850">5850</a><a id="L5851" href="#L5851">5851</a><a id="L5852" href="#L5852">5852</a><a id="L5853" href="#L5853">5853</a><a id="L5854" href="#L5854">5854</a><a id="L5855" href="#L5855">5855</a><a id="L5856" href="#L5856">5856</a><a id="L5857" href="#L5857">5857</a><a id="L5858" href="#L5858">5858</a><a id="L5859" href="#L5859">5859</a><a id="L5860" href="#L5860">5860</a><a id="L5861" href="#L5861">5861</a><a id="L5862" href="#L5862">5862</a><a id="L5863" href="#L5863">5863</a><a id="L5864" href="#L5864">5864</a><a id="L5865" href="#L5865">5865</a><a id="L5866" href="#L5866">5866</a><a id="L5867" href="#L5867">5867</a><a id="L5868" href="#L5868">5868</a><a id="L5869" href="#L5869">5869</a><a id="L5870" href="#L5870">5870</a><a id="L5871" href="#L5871">5871</a><a id="L5872" href="#L5872">5872</a><a id="L5873" href="#L5873">5873</a><a id="L5874" href="#L5874">5874</a><a id="L5875" href="#L5875">5875</a><a id="L5876" href="#L5876">5876</a><a id="L5877" href="#L5877">5877</a><a id="L5878" href="#L5878">5878</a><a id="L5879" href="#L5879">5879</a><a id="L5880" href="#L5880">5880</a><a id="L5881" href="#L5881">5881</a><a id="L5882" href="#L5882">5882</a><a id="L5883" href="#L5883">5883</a><a id="L5884" href="#L5884">5884</a><a id="L5885" href="#L5885">5885</a><a id="L5886" href="#L5886">5886</a><a id="L5887" href="#L5887">5887</a><a id="L5888" href="#L5888">5888</a><a id="L5889" href="#L5889">5889</a><a id="L5890" href="#L5890">5890</a><a id="L5891" href="#L5891">5891</a><a id="L5892" href="#L5892">5892</a><a id="L5893" href="#L5893">5893</a><a id="L5894" href="#L5894">5894</a><a id="L5895" href="#L5895">5895</a><a id="L5896" href="#L5896">5896</a><a id="L5897" href="#L5897">5897</a><a id="L5898" href="#L5898">5898</a><a id="L5899" href="#L5899">5899</a><a id="L5900" href="#L5900">5900</a><a id="L5901" href="#L5901">5901</a><a id="L5902" href="#L5902">5902</a><a id="L5903" href="#L5903">5903</a><a id="L5904" href="#L5904">5904</a><a id="L5905" href="#L5905">5905</a><a id="L5906" href="#L5906">5906</a><a id="L5907" href="#L5907">5907</a><a id="L5908" href="#L5908">5908</a><a id="L5909" href="#L5909">5909</a><a id="L5910" href="#L5910">5910</a><a id="L5911" href="#L5911">5911</a><a id="L5912" href="#L5912">5912</a><a id="L5913" href="#L5913">5913</a><a id="L5914" href="#L5914">5914</a><a id="L5915" href="#L5915">5915</a><a id="L5916" href="#L5916">5916</a><a id="L5917" href="#L5917">5917</a><a id="L5918" href="#L5918">5918</a><a id="L5919" href="#L5919">5919</a><a id="L5920" href="#L5920">5920</a><a id="L5921" href="#L5921">5921</a><a id="L5922" href="#L5922">5922</a><a id="L5923" href="#L5923">5923</a><a id="L5924" href="#L5924">5924</a><a id="L5925" href="#L5925">5925</a><a id="L5926" href="#L5926">5926</a><a id="L5927" href="#L5927">5927</a><a id="L5928" href="#L5928">5928</a><a id="L5929" href="#L5929">5929</a><a id="L5930" href="#L5930">5930</a><a id="L5931" href="#L5931">5931</a><a id="L5932" href="#L5932">5932</a><a id="L5933" href="#L5933">5933</a><a id="L5934" href="#L5934">5934</a><a id="L5935" href="#L5935">5935</a><a id="L5936" href="#L5936">5936</a><a id="L5937" href="#L5937">5937</a><a id="L5938" href="#L5938">5938</a><a id="L5939" href="#L5939">5939</a><a id="L5940" href="#L5940">5940</a><a id="L5941" href="#L5941">5941</a><a id="L5942" href="#L5942">5942</a><a id="L5943" href="#L5943">5943</a><a id="L5944" href="#L5944">5944</a><a id="L5945" href="#L5945">5945</a><a id="L5946" href="#L5946">5946</a><a id="L5947" href="#L5947">5947</a><a id="L5948" href="#L5948">5948</a><a id="L5949" href="#L5949">5949</a><a id="L5950" href="#L5950">5950</a><a id="L5951" href="#L5951">5951</a><a id="L5952" href="#L5952">5952</a><a id="L5953" href="#L5953">5953</a><a id="L5954" href="#L5954">5954</a><a id="L5955" href="#L5955">5955</a><a id="L5956" href="#L5956">5956</a><a id="L5957" href="#L5957">5957</a><a id="L5958" href="#L5958">5958</a><a id="L5959" href="#L5959">5959</a><a id="L5960" href="#L5960">5960</a><a id="L5961" href="#L5961">5961</a><a id="L5962" href="#L5962">5962</a><a id="L5963" href="#L5963">5963</a><a id="L5964" href="#L5964">5964</a><a id="L5965" href="#L5965">5965</a><a id="L5966" href="#L5966">5966</a><a id="L5967" href="#L5967">5967</a><a id="L5968" href="#L5968">5968</a><a id="L5969" href="#L5969">5969</a><a id="L5970" href="#L5970">5970</a><a id="L5971" href="#L5971">5971</a><a id="L5972" href="#L5972">5972</a><a id="L5973" href="#L5973">5973</a><a id="L5974" href="#L5974">5974</a><a id="L5975" href="#L5975">5975</a><a id="L5976" href="#L5976">5976</a><a id="L5977" href="#L5977">5977</a><a id="L5978" href="#L5978">5978</a><a id="L5979" href="#L5979">5979</a><a id="L5980" href="#L5980">5980</a><a id="L5981" href="#L5981">5981</a><a id="L5982" href="#L5982">5982</a><a id="L5983" href="#L5983">5983</a><a id="L5984" href="#L5984">5984</a><a id="L5985" href="#L5985">5985</a><a id="L5986" href="#L5986">5986</a><a id="L5987" href="#L5987">5987</a><a id="L5988" href="#L5988">5988</a><a id="L5989" href="#L5989">5989</a><a id="L5990" href="#L5990">5990</a><a id="L5991" href="#L5991">5991</a><a id="L5992" href="#L5992">5992</a><a id="L5993" href="#L5993">5993</a><a id="L5994" href="#L5994">5994</a><a id="L5995" href="#L5995">5995</a><a id="L5996" href="#L5996">5996</a><a id="L5997" href="#L5997">5997</a><a id="L5998" href="#L5998">5998</a><a id="L5999" href="#L5999">5999</a><a id="L6000" href="#L6000">6000</a><a id="L6001" href="#L6001">6001</a><a id="L6002" href="#L6002">6002</a><a id="L6003" href="#L6003">6003</a><a id="L6004" href="#L6004">6004</a><a id="L6005" href="#L6005">6005</a><a id="L6006" href="#L6006">6006</a><a id="L6007" href="#L6007">6007</a><a id="L6008" href="#L6008">6008</a><a id="L6009" href="#L6009">6009</a><a id="L6010" href="#L6010">6010</a><a id="L6011" href="#L6011">6011</a><a id="L6012" href="#L6012">6012</a><a id="L6013" href="#L6013">6013</a><a id="L6014" href="#L6014">6014</a><a id="L6015" href="#L6015">6015</a><a id="L6016" href="#L6016">6016</a><a id="L6017" href="#L6017">6017</a><a id="L6018" href="#L6018">6018</a><a id="L6019" href="#L6019">6019</a><a id="L6020" href="#L6020">6020</a><a id="L6021" href="#L6021">6021</a><a id="L6022" href="#L6022">6022</a><a id="L6023" href="#L6023">6023</a><a id="L6024" href="#L6024">6024</a><a id="L6025" href="#L6025">6025</a><a id="L6026" href="#L6026">6026</a><a id="L6027" href="#L6027">6027</a><a id="L6028" href="#L6028">6028</a><a id="L6029" href="#L6029">6029</a><a id="L6030" href="#L6030">6030</a><a id="L6031" href="#L6031">6031</a><a id="L6032" href="#L6032">6032</a><a id="L6033" href="#L6033">6033</a><a id="L6034" href="#L6034">6034</a><a id="L6035" href="#L6035">6035</a><a id="L6036" href="#L6036">6036</a><a id="L6037" href="#L6037">6037</a><a id="L6038" href="#L6038">6038</a><a id="L6039" href="#L6039">6039</a><a id="L6040" href="#L6040">6040</a><a id="L6041" href="#L6041">6041</a><a id="L6042" href="#L6042">6042</a><a id="L6043" href="#L6043">6043</a><a id="L6044" href="#L6044">6044</a><a id="L6045" href="#L6045">6045</a><a id="L6046" href="#L6046">6046</a><a id="L6047" href="#L6047">6047</a><a id="L6048" href="#L6048">6048</a><a id="L6049" href="#L6049">6049</a><a id="L6050" href="#L6050">6050</a><a id="L6051" href="#L6051">6051</a><a id="L6052" href="#L6052">6052</a><a id="L6053" href="#L6053">6053</a><a id="L6054" href="#L6054">6054</a><a id="L6055" href="#L6055">6055</a><a id="L6056" href="#L6056">6056</a><a id="L6057" href="#L6057">6057</a><a id="L6058" href="#L6058">6058</a><a id="L6059" href="#L6059">6059</a><a id="L6060" href="#L6060">6060</a><a id="L6061" href="#L6061">6061</a><a id="L6062" href="#L6062">6062</a><a id="L6063" href="#L6063">6063</a><a id="L6064" href="#L6064">6064</a><a id="L6065" href="#L6065">6065</a><a id="L6066" href="#L6066">6066</a><a id="L6067" href="#L6067">6067</a><a id="L6068" href="#L6068">6068</a><a id="L6069" href="#L6069">6069</a><a id="L6070" href="#L6070">6070</a><a id="L6071" href="#L6071">6071</a><a id="L6072" href="#L6072">6072</a><a id="L6073" href="#L6073">6073</a><a id="L6074" href="#L6074">6074</a><a id="L6075" href="#L6075">6075</a><a id="L6076" href="#L6076">6076</a><a id="L6077" href="#L6077">6077</a><a id="L6078" href="#L6078">6078</a><a id="L6079" href="#L6079">6079</a><a id="L6080" href="#L6080">6080</a><a id="L6081" href="#L6081">6081</a><a id="L6082" href="#L6082">6082</a><a id="L6083" href="#L6083">6083</a><a id="L6084" href="#L6084">6084</a><a id="L6085" href="#L6085">6085</a><a id="L6086" href="#L6086">6086</a><a id="L6087" href="#L6087">6087</a><a id="L6088" href="#L6088">6088</a><a id="L6089" href="#L6089">6089</a><a id="L6090" href="#L6090">6090</a><a id="L6091" href="#L6091">6091</a><a id="L6092" href="#L6092">6092</a><a id="L6093" href="#L6093">6093</a><a id="L6094" href="#L6094">6094</a><a id="L6095" href="#L6095">6095</a><a id="L6096" href="#L6096">6096</a><a id="L6097" href="#L6097">6097</a><a id="L6098" href="#L6098">6098</a><a id="L6099" href="#L6099">6099</a><a id="L6100" href="#L6100">6100</a><a id="L6101" href="#L6101">6101</a><a id="L6102" href="#L6102">6102</a><a id="L6103" href="#L6103">6103</a><a id="L6104" href="#L6104">6104</a><a id="L6105" href="#L6105">6105</a><a id="L6106" href="#L6106">6106</a><a id="L6107" href="#L6107">6107</a><a id="L6108" href="#L6108">6108</a><a id="L6109" href="#L6109">6109</a><a id="L6110" href="#L6110">6110</a><a id="L6111" href="#L6111">6111</a><a id="L6112" href="#L6112">6112</a><a id="L6113" href="#L6113">6113</a><a id="L6114" href="#L6114">6114</a><a id="L6115" href="#L6115">6115</a><a id="L6116" href="#L6116">6116</a><a id="L6117" href="#L6117">6117</a><a id="L6118" href="#L6118">6118</a><a id="L6119" href="#L6119">6119</a><a id="L6120" href="#L6120">6120</a><a id="L6121" href="#L6121">6121</a><a id="L6122" href="#L6122">6122</a><a id="L6123" href="#L6123">6123</a><a id="L6124" href="#L6124">6124</a><a id="L6125" href="#L6125">6125</a><a id="L6126" href="#L6126">6126</a><a id="L6127" href="#L6127">6127</a><a id="L6128" href="#L6128">6128</a><a id="L6129" href="#L6129">6129</a><a id="L6130" href="#L6130">6130</a><a id="L6131" href="#L6131">6131</a><a id="L6132" href="#L6132">6132</a><a id="L6133" href="#L6133">6133</a><a id="L6134" href="#L6134">6134</a><a id="L6135" href="#L6135">6135</a><a id="L6136" href="#L6136">6136</a><a id="L6137" href="#L6137">6137</a><a id="L6138" href="#L6138">6138</a><a id="L6139" href="#L6139">6139</a><a id="L6140" href="#L6140">6140</a><a id="L6141" href="#L6141">6141</a><a id="L6142" href="#L6142">6142</a><a id="L6143" href="#L6143">6143</a><a id="L6144" href="#L6144">6144</a><a id="L6145" href="#L6145">6145</a><a id="L6146" href="#L6146">6146</a><a id="L6147" href="#L6147">6147</a><a id="L6148" href="#L6148">6148</a><a id="L6149" href="#L6149">6149</a><a id="L6150" href="#L6150">6150</a><a id="L6151" href="#L6151">6151</a><a id="L6152" href="#L6152">6152</a><a id="L6153" href="#L6153">6153</a><a id="L6154" href="#L6154">6154</a><a id="L6155" href="#L6155">6155</a><a id="L6156" href="#L6156">6156</a><a id="L6157" href="#L6157">6157</a><a id="L6158" href="#L6158">6158</a><a id="L6159" href="#L6159">6159</a><a id="L6160" href="#L6160">6160</a><a id="L6161" href="#L6161">6161</a><a id="L6162" href="#L6162">6162</a><a id="L6163" href="#L6163">6163</a><a id="L6164" href="#L6164">6164</a><a id="L6165" href="#L6165">6165</a><a id="L6166" href="#L6166">6166</a><a id="L6167" href="#L6167">6167</a><a id="L6168" href="#L6168">6168</a><a id="L6169" href="#L6169">6169</a><a id="L6170" href="#L6170">6170</a><a id="L6171" href="#L6171">6171</a><a id="L6172" href="#L6172">6172</a><a id="L6173" href="#L6173">6173</a><a id="L6174" href="#L6174">6174</a><a id="L6175" href="#L6175">6175</a><a id="L6176" href="#L6176">6176</a><a id="L6177" href="#L6177">6177</a><a id="L6178" href="#L6178">6178</a><a id="L6179" href="#L6179">6179</a><a id="L6180" href="#L6180">6180</a><a id="L6181" href="#L6181">6181</a><a id="L6182" href="#L6182">6182</a><a id="L6183" href="#L6183">6183</a><a id="L6184" href="#L6184">6184</a><a id="L6185" href="#L6185">6185</a><a id="L6186" href="#L6186">6186</a><a id="L6187" href="#L6187">6187</a><a id="L6188" href="#L6188">6188</a><a id="L6189" href="#L6189">6189</a><a id="L6190" href="#L6190">6190</a><a id="L6191" href="#L6191">6191</a><a id="L6192" href="#L6192">6192</a><a id="L6193" href="#L6193">6193</a><a id="L6194" href="#L6194">6194</a><a id="L6195" href="#L6195">6195</a><a id="L6196" href="#L6196">6196</a><a id="L6197" href="#L6197">6197</a><a id="L6198" href="#L6198">6198</a><a id="L6199" href="#L6199">6199</a><a id="L6200" href="#L6200">6200</a><a id="L6201" href="#L6201">6201</a><a id="L6202" href="#L6202">6202</a><a id="L6203" href="#L6203">6203</a><a id="L6204" href="#L6204">6204</a><a id="L6205" href="#L6205">6205</a><a id="L6206" href="#L6206">6206</a><a id="L6207" href="#L6207">6207</a><a id="L6208" href="#L6208">6208</a><a id="L6209" href="#L6209">6209</a><a id="L6210" href="#L6210">6210</a><a id="L6211" href="#L6211">6211</a><a id="L6212" href="#L6212">6212</a><a id="L6213" href="#L6213">6213</a><a id="L6214" href="#L6214">6214</a><a id="L6215" href="#L6215">6215</a><a id="L6216" href="#L6216">6216</a><a id="L6217" href="#L6217">6217</a><a id="L6218" href="#L6218">6218</a><a id="L6219" href="#L6219">6219</a><a id="L6220" href="#L6220">6220</a><a id="L6221" href="#L6221">6221</a><a id="L6222" href="#L6222">6222</a><a id="L6223" href="#L6223">6223</a><a id="L6224" href="#L6224">6224</a><a id="L6225" href="#L6225">6225</a><a id="L6226" href="#L6226">6226</a><a id="L6227" href="#L6227">6227</a><a id="L6228" href="#L6228">6228</a><a id="L6229" href="#L6229">6229</a><a id="L6230" href="#L6230">6230</a><a id="L6231" href="#L6231">6231</a><a id="L6232" href="#L6232">6232</a><a id="L6233" href="#L6233">6233</a><a id="L6234" href="#L6234">6234</a><a id="L6235" href="#L6235">6235</a><a id="L6236" href="#L6236">6236</a><a id="L6237" href="#L6237">6237</a><a id="L6238" href="#L6238">6238</a><a id="L6239" href="#L6239">6239</a><a id="L6240" href="#L6240">6240</a><a id="L6241" href="#L6241">6241</a><a id="L6242" href="#L6242">6242</a><a id="L6243" href="#L6243">6243</a><a id="L6244" href="#L6244">6244</a><a id="L6245" href="#L6245">6245</a><a id="L6246" href="#L6246">6246</a><a id="L6247" href="#L6247">6247</a><a id="L6248" href="#L6248">6248</a><a id="L6249" href="#L6249">6249</a><a id="L6250" href="#L6250">6250</a><a id="L6251" href="#L6251">6251</a><a id="L6252" href="#L6252">6252</a><a id="L6253" href="#L6253">6253</a><a id="L6254" href="#L6254">6254</a><a id="L6255" href="#L6255">6255</a><a id="L6256" href="#L6256">6256</a><a id="L6257" href="#L6257">6257</a><a id="L6258" href="#L6258">6258</a><a id="L6259" href="#L6259">6259</a><a id="L6260" href="#L6260">6260</a><a id="L6261" href="#L6261">6261</a><a id="L6262" href="#L6262">6262</a><a id="L6263" href="#L6263">6263</a><a id="L6264" href="#L6264">6264</a><a id="L6265" href="#L6265">6265</a><a id="L6266" href="#L6266">6266</a><a id="L6267" href="#L6267">6267</a><a id="L6268" href="#L6268">6268</a><a id="L6269" href="#L6269">6269</a><a id="L6270" href="#L6270">6270</a><a id="L6271" href="#L6271">6271</a><a id="L6272" href="#L6272">6272</a><a id="L6273" href="#L6273">6273</a><a id="L6274" href="#L6274">6274</a><a id="L6275" href="#L6275">6275</a><a id="L6276" href="#L6276">6276</a><a id="L6277" href="#L6277">6277</a><a id="L6278" href="#L6278">6278</a><a id="L6279" href="#L6279">6279</a><a id="L6280" href="#L6280">6280</a><a id="L6281" href="#L6281">6281</a><a id="L6282" href="#L6282">6282</a><a id="L6283" href="#L6283">6283</a><a id="L6284" href="#L6284">6284</a><a id="L6285" href="#L6285">6285</a><a id="L6286" href="#L6286">6286</a><a id="L6287" href="#L6287">6287</a><a id="L6288" href="#L6288">6288</a><a id="L6289" href="#L6289">6289</a><a id="L6290" href="#L6290">6290</a><a id="L6291" href="#L6291">6291</a><a id="L6292" href="#L6292">6292</a><a id="L6293" href="#L6293">6293</a><a id="L6294" href="#L6294">6294</a><a id="L6295" href="#L6295">6295</a><a id="L6296" href="#L6296">6296</a><a id="L6297" href="#L6297">6297</a><a id="L6298" href="#L6298">6298</a><a id="L6299" href="#L6299">6299</a><a id="L6300" href="#L6300">6300</a><a id="L6301" href="#L6301">6301</a><a id="L6302" href="#L6302">6302</a><a id="L6303" href="#L6303">6303</a><a id="L6304" href="#L6304">6304</a><a id="L6305" href="#L6305">6305</a><a id="L6306" href="#L6306">6306</a><a id="L6307" href="#L6307">6307</a><a id="L6308" href="#L6308">6308</a><a id="L6309" href="#L6309">6309</a><a id="L6310" href="#L6310">6310</a><a id="L6311" href="#L6311">6311</a><a id="L6312" href="#L6312">6312</a><a id="L6313" href="#L6313">6313</a><a id="L6314" href="#L6314">6314</a><a id="L6315" href="#L6315">6315</a><a id="L6316" href="#L6316">6316</a><a id="L6317" href="#L6317">6317</a><a id="L6318" href="#L6318">6318</a><a id="L6319" href="#L6319">6319</a><a id="L6320" href="#L6320">6320</a><a id="L6321" href="#L6321">6321</a><a id="L6322" href="#L6322">6322</a><a id="L6323" href="#L6323">6323</a><a id="L6324" href="#L6324">6324</a><a id="L6325" href="#L6325">6325</a><a id="L6326" href="#L6326">6326</a><a id="L6327" href="#L6327">6327</a><a id="L6328" href="#L6328">6328</a><a id="L6329" href="#L6329">6329</a><a id="L6330" href="#L6330">6330</a><a id="L6331" href="#L6331">6331</a><a id="L6332" href="#L6332">6332</a><a id="L6333" href="#L6333">6333</a><a id="L6334" href="#L6334">6334</a><a id="L6335" href="#L6335">6335</a><a id="L6336" href="#L6336">6336</a><a id="L6337" href="#L6337">6337</a><a id="L6338" href="#L6338">6338</a><a id="L6339" href="#L6339">6339</a><a id="L6340" href="#L6340">6340</a><a id="L6341" href="#L6341">6341</a><a id="L6342" href="#L6342">6342</a><a id="L6343" href="#L6343">6343</a><a id="L6344" href="#L6344">6344</a><a id="L6345" href="#L6345">6345</a><a id="L6346" href="#L6346">6346</a><a id="L6347" href="#L6347">6347</a><a id="L6348" href="#L6348">6348</a><a id="L6349" href="#L6349">6349</a><a id="L6350" href="#L6350">6350</a><a id="L6351" href="#L6351">6351</a><a id="L6352" href="#L6352">6352</a><a id="L6353" href="#L6353">6353</a><a id="L6354" href="#L6354">6354</a><a id="L6355" href="#L6355">6355</a><a id="L6356" href="#L6356">6356</a><a id="L6357" href="#L6357">6357</a><a id="L6358" href="#L6358">6358</a><a id="L6359" href="#L6359">6359</a><a id="L6360" href="#L6360">6360</a><a id="L6361" href="#L6361">6361</a><a id="L6362" href="#L6362">6362</a><a id="L6363" href="#L6363">6363</a><a id="L6364" href="#L6364">6364</a><a id="L6365" href="#L6365">6365</a><a id="L6366" href="#L6366">6366</a><a id="L6367" href="#L6367">6367</a><a id="L6368" href="#L6368">6368</a><a id="L6369" href="#L6369">6369</a><a id="L6370" href="#L6370">6370</a><a id="L6371" href="#L6371">6371</a><a id="L6372" href="#L6372">6372</a><a id="L6373" href="#L6373">6373</a><a id="L6374" href="#L6374">6374</a><a id="L6375" href="#L6375">6375</a><a id="L6376" href="#L6376">6376</a><a id="L6377" href="#L6377">6377</a><a id="L6378" href="#L6378">6378</a><a id="L6379" href="#L6379">6379</a><a id="L6380" href="#L6380">6380</a><a id="L6381" href="#L6381">6381</a><a id="L6382" href="#L6382">6382</a><a id="L6383" href="#L6383">6383</a><a id="L6384" href="#L6384">6384</a><a id="L6385" href="#L6385">6385</a><a id="L6386" href="#L6386">6386</a><a id="L6387" href="#L6387">6387</a><a id="L6388" href="#L6388">6388</a><a id="L6389" href="#L6389">6389</a><a id="L6390" href="#L6390">6390</a><a id="L6391" href="#L6391">6391</a><a id="L6392" href="#L6392">6392</a><a id="L6393" href="#L6393">6393</a><a id="L6394" href="#L6394">6394</a><a id="L6395" href="#L6395">6395</a><a id="L6396" href="#L6396">6396</a><a id="L6397" href="#L6397">6397</a><a id="L6398" href="#L6398">6398</a><a id="L6399" href="#L6399">6399</a><a id="L6400" href="#L6400">6400</a><a id="L6401" href="#L6401">6401</a><a id="L6402" href="#L6402">6402</a><a id="L6403" href="#L6403">6403</a><a id="L6404" href="#L6404">6404</a><a id="L6405" href="#L6405">6405</a><a id="L6406" href="#L6406">6406</a><a id="L6407" href="#L6407">6407</a><a id="L6408" href="#L6408">6408</a><a id="L6409" href="#L6409">6409</a><a id="L6410" href="#L6410">6410</a><a id="L6411" href="#L6411">6411</a><a id="L6412" href="#L6412">6412</a><a id="L6413" href="#L6413">6413</a><a id="L6414" href="#L6414">6414</a><a id="L6415" href="#L6415">6415</a><a id="L6416" href="#L6416">6416</a><a id="L6417" href="#L6417">6417</a><a id="L6418" href="#L6418">6418</a><a id="L6419" href="#L6419">6419</a><a id="L6420" href="#L6420">6420</a><a id="L6421" href="#L6421">6421</a><a id="L6422" href="#L6422">6422</a><a id="L6423" href="#L6423">6423</a><a id="L6424" href="#L6424">6424</a><a id="L6425" href="#L6425">6425</a><a id="L6426" href="#L6426">6426</a><a id="L6427" href="#L6427">6427</a><a id="L6428" href="#L6428">6428</a><a id="L6429" href="#L6429">6429</a><a id="L6430" href="#L6430">6430</a><a id="L6431" href="#L6431">6431</a><a id="L6432" href="#L6432">6432</a><a id="L6433" href="#L6433">6433</a><a id="L6434" href="#L6434">6434</a><a id="L6435" href="#L6435">6435</a><a id="L6436" href="#L6436">6436</a><a id="L6437" href="#L6437">6437</a><a id="L6438" href="#L6438">6438</a><a id="L6439" href="#L6439">6439</a><a id="L6440" href="#L6440">6440</a><a id="L6441" href="#L6441">6441</a><a id="L6442" href="#L6442">6442</a><a id="L6443" href="#L6443">6443</a><a id="L6444" href="#L6444">6444</a><a id="L6445" href="#L6445">6445</a><a id="L6446" href="#L6446">6446</a><a id="L6447" href="#L6447">6447</a><a id="L6448" href="#L6448">6448</a><a id="L6449" href="#L6449">6449</a><a id="L6450" href="#L6450">6450</a><a id="L6451" href="#L6451">6451</a><a id="L6452" href="#L6452">6452</a><a id="L6453" href="#L6453">6453</a><a id="L6454" href="#L6454">6454</a><a id="L6455" href="#L6455">6455</a><a id="L6456" href="#L6456">6456</a><a id="L6457" href="#L6457">6457</a><a id="L6458" href="#L6458">6458</a><a id="L6459" href="#L6459">6459</a><a id="L6460" href="#L6460">6460</a><a id="L6461" href="#L6461">6461</a><a id="L6462" href="#L6462">6462</a><a id="L6463" href="#L6463">6463</a><a id="L6464" href="#L6464">6464</a><a id="L6465" href="#L6465">6465</a><a id="L6466" href="#L6466">6466</a><a id="L6467" href="#L6467">6467</a><a id="L6468" href="#L6468">6468</a><a id="L6469" href="#L6469">6469</a><a id="L6470" href="#L6470">6470</a><a id="L6471" href="#L6471">6471</a><a id="L6472" href="#L6472">6472</a><a id="L6473" href="#L6473">6473</a><a id="L6474" href="#L6474">6474</a><a id="L6475" href="#L6475">6475</a><a id="L6476" href="#L6476">6476</a><a id="L6477" href="#L6477">6477</a><a id="L6478" href="#L6478">6478</a><a id="L6479" href="#L6479">6479</a><a id="L6480" href="#L6480">6480</a><a id="L6481" href="#L6481">6481</a><a id="L6482" href="#L6482">6482</a><a id="L6483" href="#L6483">6483</a><a id="L6484" href="#L6484">6484</a><a id="L6485" href="#L6485">6485</a><a id="L6486" href="#L6486">6486</a><a id="L6487" href="#L6487">6487</a><a id="L6488" href="#L6488">6488</a><a id="L6489" href="#L6489">6489</a><a id="L6490" href="#L6490">6490</a><a id="L6491" href="#L6491">6491</a><a id="L6492" href="#L6492">6492</a><a id="L6493" href="#L6493">6493</a><a id="L6494" href="#L6494">6494</a><a id="L6495" href="#L6495">6495</a><a id="L6496" href="#L6496">6496</a><a id="L6497" href="#L6497">6497</a><a id="L6498" href="#L6498">6498</a><a id="L6499" href="#L6499">6499</a><a id="L6500" href="#L6500">6500</a><a id="L6501" href="#L6501">6501</a><a id="L6502" href="#L6502">6502</a><a id="L6503" href="#L6503">6503</a><a id="L6504" href="#L6504">6504</a><a id="L6505" href="#L6505">6505</a><a id="L6506" href="#L6506">6506</a><a id="L6507" href="#L6507">6507</a><a id="L6508" href="#L6508">6508</a><a id="L6509" href="#L6509">6509</a><a id="L6510" href="#L6510">6510</a><a id="L6511" href="#L6511">6511</a><a id="L6512" href="#L6512">6512</a><a id="L6513" href="#L6513">6513</a><a id="L6514" href="#L6514">6514</a><a id="L6515" href="#L6515">6515</a><a id="L6516" href="#L6516">6516</a><a id="L6517" href="#L6517">6517</a><a id="L6518" href="#L6518">6518</a><a id="L6519" href="#L6519">6519</a><a id="L6520" href="#L6520">6520</a><a id="L6521" href="#L6521">6521</a><a id="L6522" href="#L6522">6522</a><a id="L6523" href="#L6523">6523</a><a id="L6524" href="#L6524">6524</a><a id="L6525" href="#L6525">6525</a><a id="L6526" href="#L6526">6526</a><a id="L6527" href="#L6527">6527</a><a id="L6528" href="#L6528">6528</a><a id="L6529" href="#L6529">6529</a><a id="L6530" href="#L6530">6530</a><a id="L6531" href="#L6531">6531</a><a id="L6532" href="#L6532">6532</a><a id="L6533" href="#L6533">6533</a><a id="L6534" href="#L6534">6534</a><a id="L6535" href="#L6535">6535</a><a id="L6536" href="#L6536">6536</a><a id="L6537" href="#L6537">6537</a><a id="L6538" href="#L6538">6538</a><a id="L6539" href="#L6539">6539</a><a id="L6540" href="#L6540">6540</a><a id="L6541" href="#L6541">6541</a><a id="L6542" href="#L6542">6542</a><a id="L6543" href="#L6543">6543</a><a id="L6544" href="#L6544">6544</a><a id="L6545" href="#L6545">6545</a><a id="L6546" href="#L6546">6546</a><a id="L6547" href="#L6547">6547</a><a id="L6548" href="#L6548">6548</a><a id="L6549" href="#L6549">6549</a><a id="L6550" href="#L6550">6550</a><a id="L6551" href="#L6551">6551</a><a id="L6552" href="#L6552">6552</a><a id="L6553" href="#L6553">6553</a><a id="L6554" href="#L6554">6554</a><a id="L6555" href="#L6555">6555</a><a id="L6556" href="#L6556">6556</a><a id="L6557" href="#L6557">6557</a><a id="L6558" href="#L6558">6558</a><a id="L6559" href="#L6559">6559</a><a id="L6560" href="#L6560">6560</a><a id="L6561" href="#L6561">6561</a><a id="L6562" href="#L6562">6562</a><a id="L6563" href="#L6563">6563</a><a id="L6564" href="#L6564">6564</a><a id="L6565" href="#L6565">6565</a><a id="L6566" href="#L6566">6566</a><a id="L6567" href="#L6567">6567</a><a id="L6568" href="#L6568">6568</a><a id="L6569" href="#L6569">6569</a><a id="L6570" href="#L6570">6570</a><a id="L6571" href="#L6571">6571</a><a id="L6572" href="#L6572">6572</a><a id="L6573" href="#L6573">6573</a><a id="L6574" href="#L6574">6574</a><a id="L6575" href="#L6575">6575</a><a id="L6576" href="#L6576">6576</a><a id="L6577" href="#L6577">6577</a><a id="L6578" href="#L6578">6578</a><a id="L6579" href="#L6579">6579</a><a id="L6580" href="#L6580">6580</a><a id="L6581" href="#L6581">6581</a><a id="L6582" href="#L6582">6582</a><a id="L6583" href="#L6583">6583</a><a id="L6584" href="#L6584">6584</a><a id="L6585" href="#L6585">6585</a><a id="L6586" href="#L6586">6586</a><a id="L6587" href="#L6587">6587</a><a id="L6588" href="#L6588">6588</a><a id="L6589" href="#L6589">6589</a><a id="L6590" href="#L6590">6590</a><a id="L6591" href="#L6591">6591</a><a id="L6592" href="#L6592">6592</a><a id="L6593" href="#L6593">6593</a><a id="L6594" href="#L6594">6594</a><a id="L6595" href="#L6595">6595</a><a id="L6596" href="#L6596">6596</a><a id="L6597" href="#L6597">6597</a><a id="L6598" href="#L6598">6598</a><a id="L6599" href="#L6599">6599</a><a id="L6600" href="#L6600">6600</a><a id="L6601" href="#L6601">6601</a><a id="L6602" href="#L6602">6602</a><a id="L6603" href="#L6603">6603</a><a id="L6604" href="#L6604">6604</a><a id="L6605" href="#L6605">6605</a><a id="L6606" href="#L6606">6606</a><a id="L6607" href="#L6607">6607</a><a id="L6608" href="#L6608">6608</a><a id="L6609" href="#L6609">6609</a><a id="L6610" href="#L6610">6610</a><a id="L6611" href="#L6611">6611</a><a id="L6612" href="#L6612">6612</a><a id="L6613" href="#L6613">6613</a><a id="L6614" href="#L6614">6614</a><a id="L6615" href="#L6615">6615</a><a id="L6616" href="#L6616">6616</a><a id="L6617" href="#L6617">6617</a><a id="L6618" href="#L6618">6618</a><a id="L6619" href="#L6619">6619</a><a id="L6620" href="#L6620">6620</a><a id="L6621" href="#L6621">6621</a><a id="L6622" href="#L6622">6622</a><a id="L6623" href="#L6623">6623</a><a id="L6624" href="#L6624">6624</a><a id="L6625" href="#L6625">6625</a><a id="L6626" href="#L6626">6626</a><a id="L6627" href="#L6627">6627</a><a id="L6628" href="#L6628">6628</a><a id="L6629" href="#L6629">6629</a><a id="L6630" href="#L6630">6630</a><a id="L6631" href="#L6631">6631</a><a id="L6632" href="#L6632">6632</a><a id="L6633" href="#L6633">6633</a><a id="L6634" href="#L6634">6634</a><a id="L6635" href="#L6635">6635</a><a id="L6636" href="#L6636">6636</a><a id="L6637" href="#L6637">6637</a><a id="L6638" href="#L6638">6638</a><a id="L6639" href="#L6639">6639</a><a id="L6640" href="#L6640">6640</a><a id="L6641" href="#L6641">6641</a><a id="L6642" href="#L6642">6642</a><a id="L6643" href="#L6643">6643</a><a id="L6644" href="#L6644">6644</a><a id="L6645" href="#L6645">6645</a><a id="L6646" href="#L6646">6646</a><a id="L6647" href="#L6647">6647</a><a id="L6648" href="#L6648">6648</a><a id="L6649" href="#L6649">6649</a><a id="L6650" href="#L6650">6650</a><a id="L6651" href="#L6651">6651</a><a id="L6652" href="#L6652">6652</a><a id="L6653" href="#L6653">6653</a><a id="L6654" href="#L6654">6654</a><a id="L6655" href="#L6655">6655</a><a id="L6656" href="#L6656">6656</a><a id="L6657" href="#L6657">6657</a><a id="L6658" href="#L6658">6658</a><a id="L6659" href="#L6659">6659</a><a id="L6660" href="#L6660">6660</a><a id="L6661" href="#L6661">6661</a><a id="L6662" href="#L6662">6662</a><a id="L6663" href="#L6663">6663</a><a id="L6664" href="#L6664">6664</a><a id="L6665" href="#L6665">6665</a><a id="L6666" href="#L6666">6666</a><a id="L6667" href="#L6667">6667</a><a id="L6668" href="#L6668">6668</a><a id="L6669" href="#L6669">6669</a><a id="L6670" href="#L6670">6670</a><a id="L6671" href="#L6671">6671</a><a id="L6672" href="#L6672">6672</a><a id="L6673" href="#L6673">6673</a><a id="L6674" href="#L6674">6674</a><a id="L6675" href="#L6675">6675</a><a id="L6676" href="#L6676">6676</a><a id="L6677" href="#L6677">6677</a><a id="L6678" href="#L6678">6678</a><a id="L6679" href="#L6679">6679</a><a id="L6680" href="#L6680">6680</a><a id="L6681" href="#L6681">6681</a><a id="L6682" href="#L6682">6682</a><a id="L6683" href="#L6683">6683</a><a id="L6684" href="#L6684">6684</a><a id="L6685" href="#L6685">6685</a><a id="L6686" href="#L6686">6686</a><a id="L6687" href="#L6687">6687</a><a id="L6688" href="#L6688">6688</a><a id="L6689" href="#L6689">6689</a><a id="L6690" href="#L6690">6690</a><a id="L6691" href="#L6691">6691</a><a id="L6692" href="#L6692">6692</a><a id="L6693" href="#L6693">6693</a><a id="L6694" href="#L6694">6694</a><a id="L6695" href="#L6695">6695</a><a id="L6696" href="#L6696">6696</a><a id="L6697" href="#L6697">6697</a><a id="L6698" href="#L6698">6698</a><a id="L6699" href="#L6699">6699</a><a id="L6700" href="#L6700">6700</a><a id="L6701" href="#L6701">6701</a><a id="L6702" href="#L6702">6702</a><a id="L6703" href="#L6703">6703</a><a id="L6704" href="#L6704">6704</a><a id="L6705" href="#L6705">6705</a><a id="L6706" href="#L6706">6706</a><a id="L6707" href="#L6707">6707</a><a id="L6708" href="#L6708">6708</a><a id="L6709" href="#L6709">6709</a><a id="L6710" href="#L6710">6710</a><a id="L6711" href="#L6711">6711</a><a id="L6712" href="#L6712">6712</a><a id="L6713" href="#L6713">6713</a><a id="L6714" href="#L6714">6714</a><a id="L6715" href="#L6715">6715</a><a id="L6716" href="#L6716">6716</a><a id="L6717" href="#L6717">6717</a><a id="L6718" href="#L6718">6718</a><a id="L6719" href="#L6719">6719</a><a id="L6720" href="#L6720">6720</a><a id="L6721" href="#L6721">6721</a><a id="L6722" href="#L6722">6722</a><a id="L6723" href="#L6723">6723</a><a id="L6724" href="#L6724">6724</a><a id="L6725" href="#L6725">6725</a><a id="L6726" href="#L6726">6726</a><a id="L6727" href="#L6727">6727</a><a id="L6728" href="#L6728">6728</a><a id="L6729" href="#L6729">6729</a><a id="L6730" href="#L6730">6730</a><a id="L6731" href="#L6731">6731</a><a id="L6732" href="#L6732">6732</a><a id="L6733" href="#L6733">6733</a><a id="L6734" href="#L6734">6734</a><a id="L6735" href="#L6735">6735</a><a id="L6736" href="#L6736">6736</a><a id="L6737" href="#L6737">6737</a><a id="L6738" href="#L6738">6738</a><a id="L6739" href="#L6739">6739</a><a id="L6740" href="#L6740">6740</a><a id="L6741" href="#L6741">6741</a><a id="L6742" href="#L6742">6742</a><a id="L6743" href="#L6743">6743</a><a id="L6744" href="#L6744">6744</a><a id="L6745" href="#L6745">6745</a><a id="L6746" href="#L6746">6746</a><a id="L6747" href="#L6747">6747</a><a id="L6748" href="#L6748">6748</a><a id="L6749" href="#L6749">6749</a><a id="L6750" href="#L6750">6750</a><a id="L6751" href="#L6751">6751</a><a id="L6752" href="#L6752">6752</a><a id="L6753" href="#L6753">6753</a><a id="L6754" href="#L6754">6754</a><a id="L6755" href="#L6755">6755</a><a id="L6756" href="#L6756">6756</a><a id="L6757" href="#L6757">6757</a><a id="L6758" href="#L6758">6758</a><a id="L6759" href="#L6759">6759</a><a id="L6760" href="#L6760">6760</a><a id="L6761" href="#L6761">6761</a><a id="L6762" href="#L6762">6762</a><a id="L6763" href="#L6763">6763</a><a id="L6764" href="#L6764">6764</a><a id="L6765" href="#L6765">6765</a><a id="L6766" href="#L6766">6766</a><a id="L6767" href="#L6767">6767</a><a id="L6768" href="#L6768">6768</a><a id="L6769" href="#L6769">6769</a><a id="L6770" href="#L6770">6770</a><a id="L6771" href="#L6771">6771</a><a id="L6772" href="#L6772">6772</a><a id="L6773" href="#L6773">6773</a><a id="L6774" href="#L6774">6774</a><a id="L6775" href="#L6775">6775</a><a id="L6776" href="#L6776">6776</a><a id="L6777" href="#L6777">6777</a><a id="L6778" href="#L6778">6778</a><a id="L6779" href="#L6779">6779</a><a id="L6780" href="#L6780">6780</a><a id="L6781" href="#L6781">6781</a><a id="L6782" href="#L6782">6782</a><a id="L6783" href="#L6783">6783</a><a id="L6784" href="#L6784">6784</a><a id="L6785" href="#L6785">6785</a><a id="L6786" href="#L6786">6786</a><a id="L6787" href="#L6787">6787</a><a id="L6788" href="#L6788">6788</a><a id="L6789" href="#L6789">6789</a><a id="L6790" href="#L6790">6790</a><a id="L6791" href="#L6791">6791</a><a id="L6792" href="#L6792">6792</a><a id="L6793" href="#L6793">6793</a><a id="L6794" href="#L6794">6794</a><a id="L6795" href="#L6795">6795</a><a id="L6796" href="#L6796">6796</a><a id="L6797" href="#L6797">6797</a><a id="L6798" href="#L6798">6798</a><a id="L6799" href="#L6799">6799</a><a id="L6800" href="#L6800">6800</a><a id="L6801" href="#L6801">6801</a><a id="L6802" href="#L6802">6802</a><a id="L6803" href="#L6803">6803</a><a id="L6804" href="#L6804">6804</a><a id="L6805" href="#L6805">6805</a><a id="L6806" href="#L6806">6806</a><a id="L6807" href="#L6807">6807</a><a id="L6808" href="#L6808">6808</a><a id="L6809" href="#L6809">6809</a><a id="L6810" href="#L6810">6810</a><a id="L6811" href="#L6811">6811</a><a id="L6812" href="#L6812">6812</a><a id="L6813" href="#L6813">6813</a><a id="L6814" href="#L6814">6814</a><a id="L6815" href="#L6815">6815</a><a id="L6816" href="#L6816">6816</a><a id="L6817" href="#L6817">6817</a><a id="L6818" href="#L6818">6818</a><a id="L6819" href="#L6819">6819</a><a id="L6820" href="#L6820">6820</a><a id="L6821" href="#L6821">6821</a><a id="L6822" href="#L6822">6822</a><a id="L6823" href="#L6823">6823</a><a id="L6824" href="#L6824">6824</a><a id="L6825" href="#L6825">6825</a><a id="L6826" href="#L6826">6826</a><a id="L6827" href="#L6827">6827</a><a id="L6828" href="#L6828">6828</a><a id="L6829" href="#L6829">6829</a><a id="L6830" href="#L6830">6830</a><a id="L6831" href="#L6831">6831</a><a id="L6832" href="#L6832">6832</a><a id="L6833" href="#L6833">6833</a><a id="L6834" href="#L6834">6834</a><a id="L6835" href="#L6835">6835</a><a id="L6836" href="#L6836">6836</a><a id="L6837" href="#L6837">6837</a><a id="L6838" href="#L6838">6838</a><a id="L6839" href="#L6839">6839</a><a id="L6840" href="#L6840">6840</a><a id="L6841" href="#L6841">6841</a><a id="L6842" href="#L6842">6842</a><a id="L6843" href="#L6843">6843</a><a id="L6844" href="#L6844">6844</a><a id="L6845" href="#L6845">6845</a><a id="L6846" href="#L6846">6846</a><a id="L6847" href="#L6847">6847</a><a id="L6848" href="#L6848">6848</a><a id="L6849" href="#L6849">6849</a><a id="L6850" href="#L6850">6850</a><a id="L6851" href="#L6851">6851</a><a id="L6852" href="#L6852">6852</a><a id="L6853" href="#L6853">6853</a><a id="L6854" href="#L6854">6854</a><a id="L6855" href="#L6855">6855</a><a id="L6856" href="#L6856">6856</a><a id="L6857" href="#L6857">6857</a><a id="L6858" href="#L6858">6858</a><a id="L6859" href="#L6859">6859</a><a id="L6860" href="#L6860">6860</a><a id="L6861" href="#L6861">6861</a><a id="L6862" href="#L6862">6862</a><a id="L6863" href="#L6863">6863</a><a id="L6864" href="#L6864">6864</a><a id="L6865" href="#L6865">6865</a><a id="L6866" href="#L6866">6866</a><a id="L6867" href="#L6867">6867</a><a id="L6868" href="#L6868">6868</a><a id="L6869" href="#L6869">6869</a><a id="L6870" href="#L6870">6870</a><a id="L6871" href="#L6871">6871</a><a id="L6872" href="#L6872">6872</a><a id="L6873" href="#L6873">6873</a><a id="L6874" href="#L6874">6874</a><a id="L6875" href="#L6875">6875</a><a id="L6876" href="#L6876">6876</a><a id="L6877" href="#L6877">6877</a><a id="L6878" href="#L6878">6878</a><a id="L6879" href="#L6879">6879</a><a id="L6880" href="#L6880">6880</a><a id="L6881" href="#L6881">6881</a><a id="L6882" href="#L6882">6882</a><a id="L6883" href="#L6883">6883</a><a id="L6884" href="#L6884">6884</a><a id="L6885" href="#L6885">6885</a><a id="L6886" href="#L6886">6886</a><a id="L6887" href="#L6887">6887</a><a id="L6888" href="#L6888">6888</a><a id="L6889" href="#L6889">6889</a><a id="L6890" href="#L6890">6890</a><a id="L6891" href="#L6891">6891</a><a id="L6892" href="#L6892">6892</a><a id="L6893" href="#L6893">6893</a><a id="L6894" href="#L6894">6894</a><a id="L6895" href="#L6895">6895</a><a id="L6896" href="#L6896">6896</a><a id="L6897" href="#L6897">6897</a><a id="L6898" href="#L6898">6898</a><a id="L6899" href="#L6899">6899</a><a id="L6900" href="#L6900">6900</a><a id="L6901" href="#L6901">6901</a><a id="L6902" href="#L6902">6902</a><a id="L6903" href="#L6903">6903</a><a id="L6904" href="#L6904">6904</a><a id="L6905" href="#L6905">6905</a><a id="L6906" href="#L6906">6906</a><a id="L6907" href="#L6907">6907</a><a id="L6908" href="#L6908">6908</a><a id="L6909" href="#L6909">6909</a><a id="L6910" href="#L6910">6910</a><a id="L6911" href="#L6911">6911</a><a id="L6912" href="#L6912">6912</a><a id="L6913" href="#L6913">6913</a><a id="L6914" href="#L6914">6914</a><a id="L6915" href="#L6915">6915</a><a id="L6916" href="#L6916">6916</a><a id="L6917" href="#L6917">6917</a><a id="L6918" href="#L6918">6918</a><a id="L6919" href="#L6919">6919</a><a id="L6920" href="#L6920">6920</a><a id="L6921" href="#L6921">6921</a><a id="L6922" href="#L6922">6922</a><a id="L6923" href="#L6923">6923</a><a id="L6924" href="#L6924">6924</a><a id="L6925" href="#L6925">6925</a><a id="L6926" href="#L6926">6926</a><a id="L6927" href="#L6927">6927</a><a id="L6928" href="#L6928">6928</a><a id="L6929" href="#L6929">6929</a><a id="L6930" href="#L6930">6930</a><a id="L6931" href="#L6931">6931</a><a id="L6932" href="#L6932">6932</a><a id="L6933" href="#L6933">6933</a><a id="L6934" href="#L6934">6934</a><a id="L6935" href="#L6935">6935</a><a id="L6936" href="#L6936">6936</a><a id="L6937" href="#L6937">6937</a><a id="L6938" href="#L6938">6938</a><a id="L6939" href="#L6939">6939</a><a id="L6940" href="#L6940">6940</a><a id="L6941" href="#L6941">6941</a><a id="L6942" href="#L6942">6942</a><a id="L6943" href="#L6943">6943</a><a id="L6944" href="#L6944">6944</a><a id="L6945" href="#L6945">6945</a><a id="L6946" href="#L6946">6946</a><a id="L6947" href="#L6947">6947</a><a id="L6948" href="#L6948">6948</a><a id="L6949" href="#L6949">6949</a><a id="L6950" href="#L6950">6950</a><a id="L6951" href="#L6951">6951</a><a id="L6952" href="#L6952">6952</a><a id="L6953" href="#L6953">6953</a><a id="L6954" href="#L6954">6954</a><a id="L6955" href="#L6955">6955</a><a id="L6956" href="#L6956">6956</a><a id="L6957" href="#L6957">6957</a><a id="L6958" href="#L6958">6958</a><a id="L6959" href="#L6959">6959</a><a id="L6960" href="#L6960">6960</a><a id="L6961" href="#L6961">6961</a><a id="L6962" href="#L6962">6962</a><a id="L6963" href="#L6963">6963</a><a id="L6964" href="#L6964">6964</a><a id="L6965" href="#L6965">6965</a><a id="L6966" href="#L6966">6966</a><a id="L6967" href="#L6967">6967</a><a id="L6968" href="#L6968">6968</a><a id="L6969" href="#L6969">6969</a><a id="L6970" href="#L6970">6970</a><a id="L6971" href="#L6971">6971</a><a id="L6972" href="#L6972">6972</a><a id="L6973" href="#L6973">6973</a><a id="L6974" href="#L6974">6974</a><a id="L6975" href="#L6975">6975</a><a id="L6976" href="#L6976">6976</a><a id="L6977" href="#L6977">6977</a><a id="L6978" href="#L6978">6978</a><a id="L6979" href="#L6979">6979</a><a id="L6980" href="#L6980">6980</a><a id="L6981" href="#L6981">6981</a><a id="L6982" href="#L6982">6982</a><a id="L6983" href="#L6983">6983</a><a id="L6984" href="#L6984">6984</a><a id="L6985" href="#L6985">6985</a><a id="L6986" href="#L6986">6986</a><a id="L6987" href="#L6987">6987</a><a id="L6988" href="#L6988">6988</a><a id="L6989" href="#L6989">6989</a><a id="L6990" href="#L6990">6990</a><a id="L6991" href="#L6991">6991</a><a id="L6992" href="#L6992">6992</a><a id="L6993" href="#L6993">6993</a><a id="L6994" href="#L6994">6994</a><a id="L6995" href="#L6995">6995</a><a id="L6996" href="#L6996">6996</a><a id="L6997" href="#L6997">6997</a><a id="L6998" href="#L6998">6998</a><a id="L6999" href="#L6999">6999</a><a id="L7000" href="#L7000">7000</a><a id="L7001" href="#L7001">7001</a><a id="L7002" href="#L7002">7002</a><a id="L7003" href="#L7003">7003</a><a id="L7004" href="#L7004">7004</a><a id="L7005" href="#L7005">7005</a><a id="L7006" href="#L7006">7006</a><a id="L7007" href="#L7007">7007</a><a id="L7008" href="#L7008">7008</a><a id="L7009" href="#L7009">7009</a><a id="L7010" href="#L7010">7010</a><a id="L7011" href="#L7011">7011</a><a id="L7012" href="#L7012">7012</a><a id="L7013" href="#L7013">7013</a><a id="L7014" href="#L7014">7014</a><a id="L7015" href="#L7015">7015</a><a id="L7016" href="#L7016">7016</a><a id="L7017" href="#L7017">7017</a><a id="L7018" href="#L7018">7018</a><a id="L7019" href="#L7019">7019</a><a id="L7020" href="#L7020">7020</a><a id="L7021" href="#L7021">7021</a><a id="L7022" href="#L7022">7022</a><a id="L7023" href="#L7023">7023</a><a id="L7024" href="#L7024">7024</a><a id="L7025" href="#L7025">7025</a><a id="L7026" href="#L7026">7026</a><a id="L7027" href="#L7027">7027</a><a id="L7028" href="#L7028">7028</a><a id="L7029" href="#L7029">7029</a><a id="L7030" href="#L7030">7030</a><a id="L7031" href="#L7031">7031</a><a id="L7032" href="#L7032">7032</a><a id="L7033" href="#L7033">7033</a><a id="L7034" href="#L7034">7034</a><a id="L7035" href="#L7035">7035</a><a id="L7036" href="#L7036">7036</a><a id="L7037" href="#L7037">7037</a><a id="L7038" href="#L7038">7038</a><a id="L7039" href="#L7039">7039</a><a id="L7040" href="#L7040">7040</a><a id="L7041" href="#L7041">7041</a><a id="L7042" href="#L7042">7042</a><a id="L7043" href="#L7043">7043</a><a id="L7044" href="#L7044">7044</a><a id="L7045" href="#L7045">7045</a><a id="L7046" href="#L7046">7046</a><a id="L7047" href="#L7047">7047</a><a id="L7048" href="#L7048">7048</a><a id="L7049" href="#L7049">7049</a><a id="L7050" href="#L7050">7050</a><a id="L7051" href="#L7051">7051</a><a id="L7052" href="#L7052">7052</a><a id="L7053" href="#L7053">7053</a><a id="L7054" href="#L7054">7054</a><a id="L7055" href="#L7055">7055</a><a id="L7056" href="#L7056">7056</a><a id="L7057" href="#L7057">7057</a><a id="L7058" href="#L7058">7058</a><a id="L7059" href="#L7059">7059</a><a id="L7060" href="#L7060">7060</a><a id="L7061" href="#L7061">7061</a><a id="L7062" href="#L7062">7062</a><a id="L7063" href="#L7063">7063</a><a id="L7064" href="#L7064">7064</a><a id="L7065" href="#L7065">7065</a><a id="L7066" href="#L7066">7066</a><a id="L7067" href="#L7067">7067</a><a id="L7068" href="#L7068">7068</a><a id="L7069" href="#L7069">7069</a><a id="L7070" href="#L7070">7070</a><a id="L7071" href="#L7071">7071</a><a id="L7072" href="#L7072">7072</a><a id="L7073" href="#L7073">7073</a><a id="L7074" href="#L7074">7074</a><a id="L7075" href="#L7075">7075</a><a id="L7076" href="#L7076">7076</a><a id="L7077" href="#L7077">7077</a><a id="L7078" href="#L7078">7078</a><a id="L7079" href="#L7079">7079</a><a id="L7080" href="#L7080">7080</a><a id="L7081" href="#L7081">7081</a><a id="L7082" href="#L7082">7082</a><a id="L7083" href="#L7083">7083</a><a id="L7084" href="#L7084">7084</a><a id="L7085" href="#L7085">7085</a><a id="L7086" href="#L7086">7086</a><a id="L7087" href="#L7087">7087</a><a id="L7088" href="#L7088">7088</a><a id="L7089" href="#L7089">7089</a><a id="L7090" href="#L7090">7090</a><a id="L7091" href="#L7091">7091</a><a id="L7092" href="#L7092">7092</a><a id="L7093" href="#L7093">7093</a><a id="L7094" href="#L7094">7094</a><a id="L7095" href="#L7095">7095</a><a id="L7096" href="#L7096">7096</a><a id="L7097" href="#L7097">7097</a><a id="L7098" href="#L7098">7098</a><a id="L7099" href="#L7099">7099</a><a id="L7100" href="#L7100">7100</a><a id="L7101" href="#L7101">7101</a><a id="L7102" href="#L7102">7102</a><a id="L7103" href="#L7103">7103</a><a id="L7104" href="#L7104">7104</a><a id="L7105" href="#L7105">7105</a><a id="L7106" href="#L7106">7106</a><a id="L7107" href="#L7107">7107</a><a id="L7108" href="#L7108">7108</a><a id="L7109" href="#L7109">7109</a><a id="L7110" href="#L7110">7110</a><a id="L7111" href="#L7111">7111</a><a id="L7112" href="#L7112">7112</a><a id="L7113" href="#L7113">7113</a><a id="L7114" href="#L7114">7114</a><a id="L7115" href="#L7115">7115</a><a id="L7116" href="#L7116">7116</a><a id="L7117" href="#L7117">7117</a><a id="L7118" href="#L7118">7118</a><a id="L7119" href="#L7119">7119</a><a id="L7120" href="#L7120">7120</a><a id="L7121" href="#L7121">7121</a><a id="L7122" href="#L7122">7122</a><a id="L7123" href="#L7123">7123</a><a id="L7124" href="#L7124">7124</a><a id="L7125" href="#L7125">7125</a><a id="L7126" href="#L7126">7126</a><a id="L7127" href="#L7127">7127</a><a id="L7128" href="#L7128">7128</a><a id="L7129" href="#L7129">7129</a><a id="L7130" href="#L7130">7130</a><a id="L7131" href="#L7131">7131</a><a id="L7132" href="#L7132">7132</a><a id="L7133" href="#L7133">7133</a><a id="L7134" href="#L7134">7134</a><a id="L7135" href="#L7135">7135</a><a id="L7136" href="#L7136">7136</a><a id="L7137" href="#L7137">7137</a><a id="L7138" href="#L7138">7138</a><a id="L7139" href="#L7139">7139</a><a id="L7140" href="#L7140">7140</a><a id="L7141" href="#L7141">7141</a><a id="L7142" href="#L7142">7142</a><a id="L7143" href="#L7143">7143</a><a id="L7144" href="#L7144">7144</a><a id="L7145" href="#L7145">7145</a><a id="L7146" href="#L7146">7146</a><a id="L7147" href="#L7147">7147</a><a id="L7148" href="#L7148">7148</a><a id="L7149" href="#L7149">7149</a><a id="L7150" href="#L7150">7150</a><a id="L7151" href="#L7151">7151</a><a id="L7152" href="#L7152">7152</a><a id="L7153" href="#L7153">7153</a><a id="L7154" href="#L7154">7154</a><a id="L7155" href="#L7155">7155</a><a id="L7156" href="#L7156">7156</a><a id="L7157" href="#L7157">7157</a><a id="L7158" href="#L7158">7158</a><a id="L7159" href="#L7159">7159</a><a id="L7160" href="#L7160">7160</a><a id="L7161" href="#L7161">7161</a><a id="L7162" href="#L7162">7162</a><a id="L7163" href="#L7163">7163</a><a id="L7164" href="#L7164">7164</a><a id="L7165" href="#L7165">7165</a><a id="L7166" href="#L7166">7166</a><a id="L7167" href="#L7167">7167</a><a id="L7168" href="#L7168">7168</a><a id="L7169" href="#L7169">7169</a><a id="L7170" href="#L7170">7170</a><a id="L7171" href="#L7171">7171</a><a id="L7172" href="#L7172">7172</a><a id="L7173" href="#L7173">7173</a><a id="L7174" href="#L7174">7174</a><a id="L7175" href="#L7175">7175</a><a id="L7176" href="#L7176">7176</a><a id="L7177" href="#L7177">7177</a><a id="L7178" href="#L7178">7178</a><a id="L7179" href="#L7179">7179</a><a id="L7180" href="#L7180">7180</a><a id="L7181" href="#L7181">7181</a><a id="L7182" href="#L7182">7182</a><a id="L7183" href="#L7183">7183</a><a id="L7184" href="#L7184">7184</a><a id="L7185" href="#L7185">7185</a><a id="L7186" href="#L7186">7186</a><a id="L7187" href="#L7187">7187</a><a id="L7188" href="#L7188">7188</a><a id="L7189" href="#L7189">7189</a><a id="L7190" href="#L7190">7190</a><a id="L7191" href="#L7191">7191</a><a id="L7192" href="#L7192">7192</a><a id="L7193" href="#L7193">7193</a><a id="L7194" href="#L7194">7194</a><a id="L7195" href="#L7195">7195</a><a id="L7196" href="#L7196">7196</a><a id="L7197" href="#L7197">7197</a><a id="L7198" href="#L7198">7198</a><a id="L7199" href="#L7199">7199</a><a id="L7200" href="#L7200">7200</a><a id="L7201" href="#L7201">7201</a><a id="L7202" href="#L7202">7202</a><a id="L7203" href="#L7203">7203</a><a id="L7204" href="#L7204">7204</a><a id="L7205" href="#L7205">7205</a><a id="L7206" href="#L7206">7206</a><a id="L7207" href="#L7207">7207</a><a id="L7208" href="#L7208">7208</a><a id="L7209" href="#L7209">7209</a><a id="L7210" href="#L7210">7210</a><a id="L7211" href="#L7211">7211</a><a id="L7212" href="#L7212">7212</a><a id="L7213" href="#L7213">7213</a><a id="L7214" href="#L7214">7214</a><a id="L7215" href="#L7215">7215</a><a id="L7216" href="#L7216">7216</a><a id="L7217" href="#L7217">7217</a><a id="L7218" href="#L7218">7218</a><a id="L7219" href="#L7219">7219</a><a id="L7220" href="#L7220">7220</a><a id="L7221" href="#L7221">7221</a><a id="L7222" href="#L7222">7222</a><a id="L7223" href="#L7223">7223</a><a id="L7224" href="#L7224">7224</a><a id="L7225" href="#L7225">7225</a><a id="L7226" href="#L7226">7226</a><a id="L7227" href="#L7227">7227</a><a id="L7228" href="#L7228">7228</a><a id="L7229" href="#L7229">7229</a><a id="L7230" href="#L7230">7230</a><a id="L7231" href="#L7231">7231</a><a id="L7232" href="#L7232">7232</a><a id="L7233" href="#L7233">7233</a><a id="L7234" href="#L7234">7234</a><a id="L7235" href="#L7235">7235</a><a id="L7236" href="#L7236">7236</a><a id="L7237" href="#L7237">7237</a><a id="L7238" href="#L7238">7238</a><a id="L7239" href="#L7239">7239</a><a id="L7240" href="#L7240">7240</a><a id="L7241" href="#L7241">7241</a><a id="L7242" href="#L7242">7242</a><a id="L7243" href="#L7243">7243</a><a id="L7244" href="#L7244">7244</a><a id="L7245" href="#L7245">7245</a><a id="L7246" href="#L7246">7246</a><a id="L7247" href="#L7247">7247</a><a id="L7248" href="#L7248">7248</a><a id="L7249" href="#L7249">7249</a><a id="L7250" href="#L7250">7250</a><a id="L7251" href="#L7251">7251</a><a id="L7252" href="#L7252">7252</a><a id="L7253" href="#L7253">7253</a><a id="L7254" href="#L7254">7254</a><a id="L7255" href="#L7255">7255</a><a id="L7256" href="#L7256">7256</a><a id="L7257" href="#L7257">7257</a><a id="L7258" href="#L7258">7258</a><a id="L7259" href="#L7259">7259</a><a id="L7260" href="#L7260">7260</a><a id="L7261" href="#L7261">7261</a><a id="L7262" href="#L7262">7262</a><a id="L7263" href="#L7263">7263</a><a id="L7264" href="#L7264">7264</a><a id="L7265" href="#L7265">7265</a><a id="L7266" href="#L7266">7266</a><a id="L7267" href="#L7267">7267</a><a id="L7268" href="#L7268">7268</a><a id="L7269" href="#L7269">7269</a><a id="L7270" href="#L7270">7270</a><a id="L7271" href="#L7271">7271</a><a id="L7272" href="#L7272">7272</a><a id="L7273" href="#L7273">7273</a><a id="L7274" href="#L7274">7274</a><a id="L7275" href="#L7275">7275</a><a id="L7276" href="#L7276">7276</a><a id="L7277" href="#L7277">7277</a><a id="L7278" href="#L7278">7278</a><a id="L7279" href="#L7279">7279</a><a id="L7280" href="#L7280">7280</a><a id="L7281" href="#L7281">7281</a><a id="L7282" href="#L7282">7282</a><a id="L7283" href="#L7283">7283</a><a id="L7284" href="#L7284">7284</a><a id="L7285" href="#L7285">7285</a><a id="L7286" href="#L7286">7286</a><a id="L7287" href="#L7287">7287</a><a id="L7288" href="#L7288">7288</a><a id="L7289" href="#L7289">7289</a><a id="L7290" href="#L7290">7290</a><a id="L7291" href="#L7291">7291</a><a id="L7292" href="#L7292">7292</a><a id="L7293" href="#L7293">7293</a><a id="L7294" href="#L7294">7294</a><a id="L7295" href="#L7295">7295</a><a id="L7296" href="#L7296">7296</a><a id="L7297" href="#L7297">7297</a><a id="L7298" href="#L7298">7298</a><a id="L7299" href="#L7299">7299</a><a id="L7300" href="#L7300">7300</a><a id="L7301" href="#L7301">7301</a><a id="L7302" href="#L7302">7302</a><a id="L7303" href="#L7303">7303</a><a id="L7304" href="#L7304">7304</a><a id="L7305" href="#L7305">7305</a><a id="L7306" href="#L7306">7306</a><a id="L7307" href="#L7307">7307</a><a id="L7308" href="#L7308">7308</a><a id="L7309" href="#L7309">7309</a><a id="L7310" href="#L7310">7310</a><a id="L7311" href="#L7311">7311</a><a id="L7312" href="#L7312">7312</a><a id="L7313" href="#L7313">7313</a><a id="L7314" href="#L7314">7314</a><a id="L7315" href="#L7315">7315</a><a id="L7316" href="#L7316">7316</a><a id="L7317" href="#L7317">7317</a><a id="L7318" href="#L7318">7318</a><a id="L7319" href="#L7319">7319</a><a id="L7320" href="#L7320">7320</a><a id="L7321" href="#L7321">7321</a><a id="L7322" href="#L7322">7322</a><a id="L7323" href="#L7323">7323</a><a id="L7324" href="#L7324">7324</a><a id="L7325" href="#L7325">7325</a><a id="L7326" href="#L7326">7326</a><a id="L7327" href="#L7327">7327</a><a id="L7328" href="#L7328">7328</a><a id="L7329" href="#L7329">7329</a><a id="L7330" href="#L7330">7330</a><a id="L7331" href="#L7331">7331</a><a id="L7332" href="#L7332">7332</a><a id="L7333" href="#L7333">7333</a><a id="L7334" href="#L7334">7334</a><a id="L7335" href="#L7335">7335</a><a id="L7336" href="#L7336">7336</a><a id="L7337" href="#L7337">7337</a><a id="L7338" href="#L7338">7338</a><a id="L7339" href="#L7339">7339</a><a id="L7340" href="#L7340">7340</a><a id="L7341" href="#L7341">7341</a><a id="L7342" href="#L7342">7342</a><a id="L7343" href="#L7343">7343</a><a id="L7344" href="#L7344">7344</a><a id="L7345" href="#L7345">7345</a><a id="L7346" href="#L7346">7346</a><a id="L7347" href="#L7347">7347</a><a id="L7348" href="#L7348">7348</a><a id="L7349" href="#L7349">7349</a><a id="L7350" href="#L7350">7350</a><a id="L7351" href="#L7351">7351</a><a id="L7352" href="#L7352">7352</a><a id="L7353" href="#L7353">7353</a><a id="L7354" href="#L7354">7354</a><a id="L7355" href="#L7355">7355</a><a id="L7356" href="#L7356">7356</a><a id="L7357" href="#L7357">7357</a><a id="L7358" href="#L7358">7358</a><a id="L7359" href="#L7359">7359</a><a id="L7360" href="#L7360">7360</a><a id="L7361" href="#L7361">7361</a><a id="L7362" href="#L7362">7362</a><a id="L7363" href="#L7363">7363</a><a id="L7364" href="#L7364">7364</a><a id="L7365" href="#L7365">7365</a><a id="L7366" href="#L7366">7366</a><a id="L7367" href="#L7367">7367</a><a id="L7368" href="#L7368">7368</a><a id="L7369" href="#L7369">7369</a><a id="L7370" href="#L7370">7370</a><a id="L7371" href="#L7371">7371</a><a id="L7372" href="#L7372">7372</a><a id="L7373" href="#L7373">7373</a><a id="L7374" href="#L7374">7374</a><a id="L7375" href="#L7375">7375</a><a id="L7376" href="#L7376">7376</a><a id="L7377" href="#L7377">7377</a><a id="L7378" href="#L7378">7378</a><a id="L7379" href="#L7379">7379</a><a id="L7380" href="#L7380">7380</a><a id="L7381" href="#L7381">7381</a><a id="L7382" href="#L7382">7382</a><a id="L7383" href="#L7383">7383</a><a id="L7384" href="#L7384">7384</a><a id="L7385" href="#L7385">7385</a><a id="L7386" href="#L7386">7386</a><a id="L7387" href="#L7387">7387</a><a id="L7388" href="#L7388">7388</a><a id="L7389" href="#L7389">7389</a><a id="L7390" href="#L7390">7390</a><a id="L7391" href="#L7391">7391</a><a id="L7392" href="#L7392">7392</a><a id="L7393" href="#L7393">7393</a><a id="L7394" href="#L7394">7394</a><a id="L7395" href="#L7395">7395</a><a id="L7396" href="#L7396">7396</a><a id="L7397" href="#L7397">7397</a><a id="L7398" href="#L7398">7398</a><a id="L7399" href="#L7399">7399</a><a id="L7400" href="#L7400">7400</a><a id="L7401" href="#L7401">7401</a><a id="L7402" href="#L7402">7402</a><a id="L7403" href="#L7403">7403</a><a id="L7404" href="#L7404">7404</a><a id="L7405" href="#L7405">7405</a><a id="L7406" href="#L7406">7406</a><a id="L7407" href="#L7407">7407</a><a id="L7408" href="#L7408">7408</a><a id="L7409" href="#L7409">7409</a><a id="L7410" href="#L7410">7410</a><a id="L7411" href="#L7411">7411</a><a id="L7412" href="#L7412">7412</a><a id="L7413" href="#L7413">7413</a><a id="L7414" href="#L7414">7414</a><a id="L7415" href="#L7415">7415</a><a id="L7416" href="#L7416">7416</a><a id="L7417" href="#L7417">7417</a><a id="L7418" href="#L7418">7418</a><a id="L7419" href="#L7419">7419</a><a id="L7420" href="#L7420">7420</a><a id="L7421" href="#L7421">7421</a><a id="L7422" href="#L7422">7422</a><a id="L7423" href="#L7423">7423</a><a id="L7424" href="#L7424">7424</a><a id="L7425" href="#L7425">7425</a><a id="L7426" href="#L7426">7426</a><a id="L7427" href="#L7427">7427</a><a id="L7428" href="#L7428">7428</a><a id="L7429" href="#L7429">7429</a><a id="L7430" href="#L7430">7430</a><a id="L7431" href="#L7431">7431</a><a id="L7432" href="#L7432">7432</a><a id="L7433" href="#L7433">7433</a><a id="L7434" href="#L7434">7434</a><a id="L7435" href="#L7435">7435</a><a id="L7436" href="#L7436">7436</a><a id="L7437" href="#L7437">7437</a><a id="L7438" href="#L7438">7438</a><a id="L7439" href="#L7439">7439</a><a id="L7440" href="#L7440">7440</a><a id="L7441" href="#L7441">7441</a><a id="L7442" href="#L7442">7442</a><a id="L7443" href="#L7443">7443</a><a id="L7444" href="#L7444">7444</a><a id="L7445" href="#L7445">7445</a><a id="L7446" href="#L7446">7446</a><a id="L7447" href="#L7447">7447</a><a id="L7448" href="#L7448">7448</a><a id="L7449" href="#L7449">7449</a><a id="L7450" href="#L7450">7450</a><a id="L7451" href="#L7451">7451</a><a id="L7452" href="#L7452">7452</a><a id="L7453" href="#L7453">7453</a><a id="L7454" href="#L7454">7454</a><a id="L7455" href="#L7455">7455</a><a id="L7456" href="#L7456">7456</a><a id="L7457" href="#L7457">7457</a><a id="L7458" href="#L7458">7458</a><a id="L7459" href="#L7459">7459</a><a id="L7460" href="#L7460">7460</a><a id="L7461" href="#L7461">7461</a><a id="L7462" href="#L7462">7462</a><a id="L7463" href="#L7463">7463</a><a id="L7464" href="#L7464">7464</a><a id="L7465" href="#L7465">7465</a><a id="L7466" href="#L7466">7466</a><a id="L7467" href="#L7467">7467</a><a id="L7468" href="#L7468">7468</a><a id="L7469" href="#L7469">7469</a><a id="L7470" href="#L7470">7470</a><a id="L7471" href="#L7471">7471</a><a id="L7472" href="#L7472">7472</a><a id="L7473" href="#L7473">7473</a><a id="L7474" href="#L7474">7474</a><a id="L7475" href="#L7475">7475</a><a id="L7476" href="#L7476">7476</a><a id="L7477" href="#L7477">7477</a><a id="L7478" href="#L7478">7478</a><a id="L7479" href="#L7479">7479</a><a id="L7480" href="#L7480">7480</a><a id="L7481" href="#L7481">7481</a><a id="L7482" href="#L7482">7482</a><a id="L7483" href="#L7483">7483</a><a id="L7484" href="#L7484">7484</a><a id="L7485" href="#L7485">7485</a><a id="L7486" href="#L7486">7486</a><a id="L7487" href="#L7487">7487</a><a id="L7488" href="#L7488">7488</a><a id="L7489" href="#L7489">7489</a><a id="L7490" href="#L7490">7490</a><a id="L7491" href="#L7491">7491</a><a id="L7492" href="#L7492">7492</a><a id="L7493" href="#L7493">7493</a><a id="L7494" href="#L7494">7494</a><a id="L7495" href="#L7495">7495</a><a id="L7496" href="#L7496">7496</a><a id="L7497" href="#L7497">7497</a><a id="L7498" href="#L7498">7498</a><a id="L7499" href="#L7499">7499</a><a id="L7500" href="#L7500">7500</a><a id="L7501" href="#L7501">7501</a><a id="L7502" href="#L7502">7502</a><a id="L7503" href="#L7503">7503</a><a id="L7504" href="#L7504">7504</a><a id="L7505" href="#L7505">7505</a><a id="L7506" href="#L7506">7506</a><a id="L7507" href="#L7507">7507</a><a id="L7508" href="#L7508">7508</a><a id="L7509" href="#L7509">7509</a><a id="L7510" href="#L7510">7510</a><a id="L7511" href="#L7511">7511</a><a id="L7512" href="#L7512">7512</a><a id="L7513" href="#L7513">7513</a><a id="L7514" href="#L7514">7514</a><a id="L7515" href="#L7515">7515</a><a id="L7516" href="#L7516">7516</a><a id="L7517" href="#L7517">7517</a><a id="L7518" href="#L7518">7518</a><a id="L7519" href="#L7519">7519</a><a id="L7520" href="#L7520">7520</a><a id="L7521" href="#L7521">7521</a><a id="L7522" href="#L7522">7522</a><a id="L7523" href="#L7523">7523</a><a id="L7524" href="#L7524">7524</a><a id="L7525" href="#L7525">7525</a><a id="L7526" href="#L7526">7526</a><a id="L7527" href="#L7527">7527</a><a id="L7528" href="#L7528">7528</a><a id="L7529" href="#L7529">7529</a><a id="L7530" href="#L7530">7530</a><a id="L7531" href="#L7531">7531</a><a id="L7532" href="#L7532">7532</a><a id="L7533" href="#L7533">7533</a><a id="L7534" href="#L7534">7534</a><a id="L7535" href="#L7535">7535</a><a id="L7536" href="#L7536">7536</a><a id="L7537" href="#L7537">7537</a><a id="L7538" href="#L7538">7538</a><a id="L7539" href="#L7539">7539</a><a id="L7540" href="#L7540">7540</a><a id="L7541" href="#L7541">7541</a><a id="L7542" href="#L7542">7542</a><a id="L7543" href="#L7543">7543</a><a id="L7544" href="#L7544">7544</a><a id="L7545" href="#L7545">7545</a><a id="L7546" href="#L7546">7546</a><a id="L7547" href="#L7547">7547</a><a id="L7548" href="#L7548">7548</a><a id="L7549" href="#L7549">7549</a><a id="L7550" href="#L7550">7550</a><a id="L7551" href="#L7551">7551</a><a id="L7552" href="#L7552">7552</a><a id="L7553" href="#L7553">7553</a><a id="L7554" href="#L7554">7554</a><a id="L7555" href="#L7555">7555</a><a id="L7556" href="#L7556">7556</a><a id="L7557" href="#L7557">7557</a><a id="L7558" href="#L7558">7558</a><a id="L7559" href="#L7559">7559</a><a id="L7560" href="#L7560">7560</a><a id="L7561" href="#L7561">7561</a><a id="L7562" href="#L7562">7562</a><a id="L7563" href="#L7563">7563</a><a id="L7564" href="#L7564">7564</a><a id="L7565" href="#L7565">7565</a><a id="L7566" href="#L7566">7566</a><a id="L7567" href="#L7567">7567</a><a id="L7568" href="#L7568">7568</a><a id="L7569" href="#L7569">7569</a><a id="L7570" href="#L7570">7570</a><a id="L7571" href="#L7571">7571</a><a id="L7572" href="#L7572">7572</a><a id="L7573" href="#L7573">7573</a><a id="L7574" href="#L7574">7574</a><a id="L7575" href="#L7575">7575</a><a id="L7576" href="#L7576">7576</a><a id="L7577" href="#L7577">7577</a><a id="L7578" href="#L7578">7578</a><a id="L7579" href="#L7579">7579</a><a id="L7580" href="#L7580">7580</a><a id="L7581" href="#L7581">7581</a><a id="L7582" href="#L7582">7582</a><a id="L7583" href="#L7583">7583</a><a id="L7584" href="#L7584">7584</a><a id="L7585" href="#L7585">7585</a><a id="L7586" href="#L7586">7586</a><a id="L7587" href="#L7587">7587</a><a id="L7588" href="#L7588">7588</a><a id="L7589" href="#L7589">7589</a><a id="L7590" href="#L7590">7590</a><a id="L7591" href="#L7591">7591</a><a id="L7592" href="#L7592">7592</a><a id="L7593" href="#L7593">7593</a><a id="L7594" href="#L7594">7594</a><a id="L7595" href="#L7595">7595</a><a id="L7596" href="#L7596">7596</a><a id="L7597" href="#L7597">7597</a><a id="L7598" href="#L7598">7598</a><a id="L7599" href="#L7599">7599</a><a id="L7600" href="#L7600">7600</a><a id="L7601" href="#L7601">7601</a><a id="L7602" href="#L7602">7602</a><a id="L7603" href="#L7603">7603</a><a id="L7604" href="#L7604">7604</a><a id="L7605" href="#L7605">7605</a><a id="L7606" href="#L7606">7606</a><a id="L7607" href="#L7607">7607</a><a id="L7608" href="#L7608">7608</a><a id="L7609" href="#L7609">7609</a><a id="L7610" href="#L7610">7610</a><a id="L7611" href="#L7611">7611</a><a id="L7612" href="#L7612">7612</a><a id="L7613" href="#L7613">7613</a><a id="L7614" href="#L7614">7614</a><a id="L7615" href="#L7615">7615</a><a id="L7616" href="#L7616">7616</a><a id="L7617" href="#L7617">7617</a><a id="L7618" href="#L7618">7618</a><a id="L7619" href="#L7619">7619</a><a id="L7620" href="#L7620">7620</a><a id="L7621" href="#L7621">7621</a><a id="L7622" href="#L7622">7622</a><a id="L7623" href="#L7623">7623</a><a id="L7624" href="#L7624">7624</a><a id="L7625" href="#L7625">7625</a><a id="L7626" href="#L7626">7626</a><a id="L7627" href="#L7627">7627</a><a id="L7628" href="#L7628">7628</a><a id="L7629" href="#L7629">7629</a><a id="L7630" href="#L7630">7630</a><a id="L7631" href="#L7631">7631</a><a id="L7632" href="#L7632">7632</a><a id="L7633" href="#L7633">7633</a><a id="L7634" href="#L7634">7634</a><a id="L7635" href="#L7635">7635</a><a id="L7636" href="#L7636">7636</a><a id="L7637" href="#L7637">7637</a><a id="L7638" href="#L7638">7638</a><a id="L7639" href="#L7639">7639</a><a id="L7640" href="#L7640">7640</a><a id="L7641" href="#L7641">7641</a><a id="L7642" href="#L7642">7642</a><a id="L7643" href="#L7643">7643</a><a id="L7644" href="#L7644">7644</a><a id="L7645" href="#L7645">7645</a><a id="L7646" href="#L7646">7646</a><a id="L7647" href="#L7647">7647</a><a id="L7648" href="#L7648">7648</a><a id="L7649" href="#L7649">7649</a><a id="L7650" href="#L7650">7650</a><a id="L7651" href="#L7651">7651</a><a id="L7652" href="#L7652">7652</a><a id="L7653" href="#L7653">7653</a><a id="L7654" href="#L7654">7654</a><a id="L7655" href="#L7655">7655</a><a id="L7656" href="#L7656">7656</a><a id="L7657" href="#L7657">7657</a><a id="L7658" href="#L7658">7658</a><a id="L7659" href="#L7659">7659</a><a id="L7660" href="#L7660">7660</a><a id="L7661" href="#L7661">7661</a><a id="L7662" href="#L7662">7662</a><a id="L7663" href="#L7663">7663</a><a id="L7664" href="#L7664">7664</a><a id="L7665" href="#L7665">7665</a><a id="L7666" href="#L7666">7666</a><a id="L7667" href="#L7667">7667</a><a id="L7668" href="#L7668">7668</a><a id="L7669" href="#L7669">7669</a><a id="L7670" href="#L7670">7670</a><a id="L7671" href="#L7671">7671</a><a id="L7672" href="#L7672">7672</a><a id="L7673" href="#L7673">7673</a><a id="L7674" href="#L7674">7674</a><a id="L7675" href="#L7675">7675</a><a id="L7676" href="#L7676">7676</a><a id="L7677" href="#L7677">7677</a><a id="L7678" href="#L7678">7678</a><a id="L7679" href="#L7679">7679</a><a id="L7680" href="#L7680">7680</a><a id="L7681" href="#L7681">7681</a><a id="L7682" href="#L7682">7682</a><a id="L7683" href="#L7683">7683</a><a id="L7684" href="#L7684">7684</a><a id="L7685" href="#L7685">7685</a><a id="L7686" href="#L7686">7686</a><a id="L7687" href="#L7687">7687</a><a id="L7688" href="#L7688">7688</a><a id="L7689" href="#L7689">7689</a><a id="L7690" href="#L7690">7690</a><a id="L7691" href="#L7691">7691</a><a id="L7692" href="#L7692">7692</a><a id="L7693" href="#L7693">7693</a><a id="L7694" href="#L7694">7694</a><a id="L7695" href="#L7695">7695</a><a id="L7696" href="#L7696">7696</a><a id="L7697" href="#L7697">7697</a><a id="L7698" href="#L7698">7698</a><a id="L7699" href="#L7699">7699</a><a id="L7700" href="#L7700">7700</a><a id="L7701" href="#L7701">7701</a><a id="L7702" href="#L7702">7702</a><a id="L7703" href="#L7703">7703</a><a id="L7704" href="#L7704">7704</a><a id="L7705" href="#L7705">7705</a><a id="L7706" href="#L7706">7706</a><a id="L7707" href="#L7707">7707</a><a id="L7708" href="#L7708">7708</a><a id="L7709" href="#L7709">7709</a><a id="L7710" href="#L7710">7710</a><a id="L7711" href="#L7711">7711</a><a id="L7712" href="#L7712">7712</a><a id="L7713" href="#L7713">7713</a><a id="L7714" href="#L7714">7714</a><a id="L7715" href="#L7715">7715</a><a id="L7716" href="#L7716">7716</a><a id="L7717" href="#L7717">7717</a><a id="L7718" href="#L7718">7718</a><a id="L7719" href="#L7719">7719</a><a id="L7720" href="#L7720">7720</a><a id="L7721" href="#L7721">7721</a><a id="L7722" href="#L7722">7722</a><a id="L7723" href="#L7723">7723</a><a id="L7724" href="#L7724">7724</a><a id="L7725" href="#L7725">7725</a><a id="L7726" href="#L7726">7726</a><a id="L7727" href="#L7727">7727</a><a id="L7728" href="#L7728">7728</a><a id="L7729" href="#L7729">7729</a><a id="L7730" href="#L7730">7730</a><a id="L7731" href="#L7731">7731</a><a id="L7732" href="#L7732">7732</a><a id="L7733" href="#L7733">7733</a><a id="L7734" href="#L7734">7734</a><a id="L7735" href="#L7735">7735</a><a id="L7736" href="#L7736">7736</a><a id="L7737" href="#L7737">7737</a><a id="L7738" href="#L7738">7738</a><a id="L7739" href="#L7739">7739</a><a id="L7740" href="#L7740">7740</a><a id="L7741" href="#L7741">7741</a><a id="L7742" href="#L7742">7742</a><a id="L7743" href="#L7743">7743</a><a id="L7744" href="#L7744">7744</a><a id="L7745" href="#L7745">7745</a><a id="L7746" href="#L7746">7746</a><a id="L7747" href="#L7747">7747</a><a id="L7748" href="#L7748">7748</a><a id="L7749" href="#L7749">7749</a><a id="L7750" href="#L7750">7750</a><a id="L7751" href="#L7751">7751</a><a id="L7752" href="#L7752">7752</a><a id="L7753" href="#L7753">7753</a><a id="L7754" href="#L7754">7754</a><a id="L7755" href="#L7755">7755</a><a id="L7756" href="#L7756">7756</a><a id="L7757" href="#L7757">7757</a><a id="L7758" href="#L7758">7758</a><a id="L7759" href="#L7759">7759</a><a id="L7760" href="#L7760">7760</a><a id="L7761" href="#L7761">7761</a><a id="L7762" href="#L7762">7762</a><a id="L7763" href="#L7763">7763</a><a id="L7764" href="#L7764">7764</a><a id="L7765" href="#L7765">7765</a><a id="L7766" href="#L7766">7766</a><a id="L7767" href="#L7767">7767</a><a id="L7768" href="#L7768">7768</a><a id="L7769" href="#L7769">7769</a><a id="L7770" href="#L7770">7770</a><a id="L7771" href="#L7771">7771</a><a id="L7772" href="#L7772">7772</a><a id="L7773" href="#L7773">7773</a><a id="L7774" href="#L7774">7774</a><a id="L7775" href="#L7775">7775</a><a id="L7776" href="#L7776">7776</a><a id="L7777" href="#L7777">7777</a><a id="L7778" href="#L7778">7778</a><a id="L7779" href="#L7779">7779</a><a id="L7780" href="#L7780">7780</a><a id="L7781" href="#L7781">7781</a><a id="L7782" href="#L7782">7782</a><a id="L7783" href="#L7783">7783</a><a id="L7784" href="#L7784">7784</a><a id="L7785" href="#L7785">7785</a><a id="L7786" href="#L7786">7786</a><a id="L7787" href="#L7787">7787</a><a id="L7788" href="#L7788">7788</a><a id="L7789" href="#L7789">7789</a><a id="L7790" href="#L7790">7790</a><a id="L7791" href="#L7791">7791</a><a id="L7792" href="#L7792">7792</a><a id="L7793" href="#L7793">7793</a><a id="L7794" href="#L7794">7794</a><a id="L7795" href="#L7795">7795</a><a id="L7796" href="#L7796">7796</a><a id="L7797" href="#L7797">7797</a><a id="L7798" href="#L7798">7798</a><a id="L7799" href="#L7799">7799</a><a id="L7800" href="#L7800">7800</a><a id="L7801" href="#L7801">7801</a><a id="L7802" href="#L7802">7802</a><a id="L7803" href="#L7803">7803</a><a id="L7804" href="#L7804">7804</a><a id="L7805" href="#L7805">7805</a><a id="L7806" href="#L7806">7806</a><a id="L7807" href="#L7807">7807</a><a id="L7808" href="#L7808">7808</a><a id="L7809" href="#L7809">7809</a><a id="L7810" href="#L7810">7810</a><a id="L7811" href="#L7811">7811</a><a id="L7812" href="#L7812">7812</a><a id="L7813" href="#L7813">7813</a><a id="L7814" href="#L7814">7814</a><a id="L7815" href="#L7815">7815</a><a id="L7816" href="#L7816">7816</a><a id="L7817" href="#L7817">7817</a><a id="L7818" href="#L7818">7818</a><a id="L7819" href="#L7819">7819</a><a id="L7820" href="#L7820">7820</a><a id="L7821" href="#L7821">7821</a><a id="L7822" href="#L7822">7822</a><a id="L7823" href="#L7823">7823</a><a id="L7824" href="#L7824">7824</a><a id="L7825" href="#L7825">7825</a><a id="L7826" href="#L7826">7826</a><a id="L7827" href="#L7827">7827</a><a id="L7828" href="#L7828">7828</a><a id="L7829" href="#L7829">7829</a><a id="L7830" href="#L7830">7830</a><a id="L7831" href="#L7831">7831</a><a id="L7832" href="#L7832">7832</a><a id="L7833" href="#L7833">7833</a><a id="L7834" href="#L7834">7834</a><a id="L7835" href="#L7835">7835</a><a id="L7836" href="#L7836">7836</a><a id="L7837" href="#L7837">7837</a><a id="L7838" href="#L7838">7838</a><a id="L7839" href="#L7839">7839</a><a id="L7840" href="#L7840">7840</a><a id="L7841" href="#L7841">7841</a><a id="L7842" href="#L7842">7842</a><a id="L7843" href="#L7843">7843</a><a id="L7844" href="#L7844">7844</a><a id="L7845" href="#L7845">7845</a><a id="L7846" href="#L7846">7846</a><a id="L7847" href="#L7847">7847</a><a id="L7848" href="#L7848">7848</a><a id="L7849" href="#L7849">7849</a><a id="L7850" href="#L7850">7850</a><a id="L7851" href="#L7851">7851</a><a id="L7852" href="#L7852">7852</a><a id="L7853" href="#L7853">7853</a><a id="L7854" href="#L7854">7854</a><a id="L7855" href="#L7855">7855</a><a id="L7856" href="#L7856">7856</a><a id="L7857" href="#L7857">7857</a><a id="L7858" href="#L7858">7858</a><a id="L7859" href="#L7859">7859</a><a id="L7860" href="#L7860">7860</a><a id="L7861" href="#L7861">7861</a><a id="L7862" href="#L7862">7862</a><a id="L7863" href="#L7863">7863</a><a id="L7864" href="#L7864">7864</a><a id="L7865" href="#L7865">7865</a><a id="L7866" href="#L7866">7866</a><a id="L7867" href="#L7867">7867</a><a id="L7868" href="#L7868">7868</a><a id="L7869" href="#L7869">7869</a><a id="L7870" href="#L7870">7870</a><a id="L7871" href="#L7871">7871</a><a id="L7872" href="#L7872">7872</a><a id="L7873" href="#L7873">7873</a><a id="L7874" href="#L7874">7874</a><a id="L7875" href="#L7875">7875</a><a id="L7876" href="#L7876">7876</a><a id="L7877" href="#L7877">7877</a><a id="L7878" href="#L7878">7878</a><a id="L7879" href="#L7879">7879</a><a id="L7880" href="#L7880">7880</a><a id="L7881" href="#L7881">7881</a><a id="L7882" href="#L7882">7882</a><a id="L7883" href="#L7883">7883</a><a id="L7884" href="#L7884">7884</a><a id="L7885" href="#L7885">7885</a><a id="L7886" href="#L7886">7886</a><a id="L7887" href="#L7887">7887</a><a id="L7888" href="#L7888">7888</a><a id="L7889" href="#L7889">7889</a><a id="L7890" href="#L7890">7890</a><a id="L7891" href="#L7891">7891</a><a id="L7892" href="#L7892">7892</a><a id="L7893" href="#L7893">7893</a><a id="L7894" href="#L7894">7894</a><a id="L7895" href="#L7895">7895</a><a id="L7896" href="#L7896">7896</a><a id="L7897" href="#L7897">7897</a><a id="L7898" href="#L7898">7898</a><a id="L7899" href="#L7899">7899</a><a id="L7900" href="#L7900">7900</a><a id="L7901" href="#L7901">7901</a><a id="L7902" href="#L7902">7902</a><a id="L7903" href="#L7903">7903</a><a id="L7904" href="#L7904">7904</a><a id="L7905" href="#L7905">7905</a><a id="L7906" href="#L7906">7906</a><a id="L7907" href="#L7907">7907</a><a id="L7908" href="#L7908">7908</a><a id="L7909" href="#L7909">7909</a><a id="L7910" href="#L7910">7910</a><a id="L7911" href="#L7911">7911</a><a id="L7912" href="#L7912">7912</a><a id="L7913" href="#L7913">7913</a><a id="L7914" href="#L7914">7914</a><a id="L7915" href="#L7915">7915</a><a id="L7916" href="#L7916">7916</a><a id="L7917" href="#L7917">7917</a><a id="L7918" href="#L7918">7918</a><a id="L7919" href="#L7919">7919</a><a id="L7920" href="#L7920">7920</a><a id="L7921" href="#L7921">7921</a><a id="L7922" href="#L7922">7922</a><a id="L7923" href="#L7923">7923</a><a id="L7924" href="#L7924">7924</a><a id="L7925" href="#L7925">7925</a><a id="L7926" href="#L7926">7926</a><a id="L7927" href="#L7927">7927</a><a id="L7928" href="#L7928">7928</a><a id="L7929" href="#L7929">7929</a><a id="L7930" href="#L7930">7930</a><a id="L7931" href="#L7931">7931</a><a id="L7932" href="#L7932">7932</a><a id="L7933" href="#L7933">7933</a><a id="L7934" href="#L7934">7934</a><a id="L7935" href="#L7935">7935</a><a id="L7936" href="#L7936">7936</a><a id="L7937" href="#L7937">7937</a><a id="L7938" href="#L7938">7938</a><a id="L7939" href="#L7939">7939</a><a id="L7940" href="#L7940">7940</a><a id="L7941" href="#L7941">7941</a><a id="L7942" href="#L7942">7942</a><a id="L7943" href="#L7943">7943</a><a id="L7944" href="#L7944">7944</a><a id="L7945" href="#L7945">7945</a><a id="L7946" href="#L7946">7946</a><a id="L7947" href="#L7947">7947</a><a id="L7948" href="#L7948">7948</a><a id="L7949" href="#L7949">7949</a><a id="L7950" href="#L7950">7950</a><a id="L7951" href="#L7951">7951</a><a id="L7952" href="#L7952">7952</a><a id="L7953" href="#L7953">7953</a><a id="L7954" href="#L7954">7954</a><a id="L7955" href="#L7955">7955</a><a id="L7956" href="#L7956">7956</a><a id="L7957" href="#L7957">7957</a><a id="L7958" href="#L7958">7958</a><a id="L7959" href="#L7959">7959</a><a id="L7960" href="#L7960">7960</a><a id="L7961" href="#L7961">7961</a><a id="L7962" href="#L7962">7962</a><a id="L7963" href="#L7963">7963</a><a id="L7964" href="#L7964">7964</a><a id="L7965" href="#L7965">7965</a><a id="L7966" href="#L7966">7966</a><a id="L7967" href="#L7967">7967</a><a id="L7968" href="#L7968">7968</a><a id="L7969" href="#L7969">7969</a><a id="L7970" href="#L7970">7970</a><a id="L7971" href="#L7971">7971</a><a id="L7972" href="#L7972">7972</a><a id="L7973" href="#L7973">7973</a><a id="L7974" href="#L7974">7974</a><a id="L7975" href="#L7975">7975</a><a id="L7976" href="#L7976">7976</a><a id="L7977" href="#L7977">7977</a><a id="L7978" href="#L7978">7978</a><a id="L7979" href="#L7979">7979</a><a id="L7980" href="#L7980">7980</a><a id="L7981" href="#L7981">7981</a><a id="L7982" href="#L7982">7982</a><a id="L7983" href="#L7983">7983</a><a id="L7984" href="#L7984">7984</a><a id="L7985" href="#L7985">7985</a><a id="L7986" href="#L7986">7986</a><a id="L7987" href="#L7987">7987</a><a id="L7988" href="#L7988">7988</a><a id="L7989" href="#L7989">7989</a><a id="L7990" href="#L7990">7990</a><a id="L7991" href="#L7991">7991</a><a id="L7992" href="#L7992">7992</a><a id="L7993" href="#L7993">7993</a><a id="L7994" href="#L7994">7994</a><a id="L7995" href="#L7995">7995</a><a id="L7996" href="#L7996">7996</a><a id="L7997" href="#L7997">7997</a><a id="L7998" href="#L7998">7998</a><a id="L7999" href="#L7999">7999</a><a id="L8000" href="#L8000">8000</a><a id="L8001" href="#L8001">8001</a><a id="L8002" href="#L8002">8002</a><a id="L8003" href="#L8003">8003</a><a id="L8004" href="#L8004">8004</a><a id="L8005" href="#L8005">8005</a><a id="L8006" href="#L8006">8006</a><a id="L8007" href="#L8007">8007</a><a id="L8008" href="#L8008">8008</a><a id="L8009" href="#L8009">8009</a><a id="L8010" href="#L8010">8010</a><a id="L8011" href="#L8011">8011</a><a id="L8012" href="#L8012">8012</a><a id="L8013" href="#L8013">8013</a><a id="L8014" href="#L8014">8014</a><a id="L8015" href="#L8015">8015</a><a id="L8016" href="#L8016">8016</a><a id="L8017" href="#L8017">8017</a><a id="L8018" href="#L8018">8018</a><a id="L8019" href="#L8019">8019</a><a id="L8020" href="#L8020">8020</a><a id="L8021" href="#L8021">8021</a><a id="L8022" href="#L8022">8022</a><a id="L8023" href="#L8023">8023</a><a id="L8024" href="#L8024">8024</a><a id="L8025" href="#L8025">8025</a><a id="L8026" href="#L8026">8026</a><a id="L8027" href="#L8027">8027</a><a id="L8028" href="#L8028">8028</a><a id="L8029" href="#L8029">8029</a><a id="L8030" href="#L8030">8030</a><a id="L8031" href="#L8031">8031</a><a id="L8032" href="#L8032">8032</a><a id="L8033" href="#L8033">8033</a><a id="L8034" href="#L8034">8034</a><a id="L8035" href="#L8035">8035</a><a id="L8036" href="#L8036">8036</a><a id="L8037" href="#L8037">8037</a><a id="L8038" href="#L8038">8038</a><a id="L8039" href="#L8039">8039</a><a id="L8040" href="#L8040">8040</a><a id="L8041" href="#L8041">8041</a><a id="L8042" href="#L8042">8042</a><a id="L8043" href="#L8043">8043</a><a id="L8044" href="#L8044">8044</a><a id="L8045" href="#L8045">8045</a><a id="L8046" href="#L8046">8046</a><a id="L8047" href="#L8047">8047</a><a id="L8048" href="#L8048">8048</a><a id="L8049" href="#L8049">8049</a><a id="L8050" href="#L8050">8050</a><a id="L8051" href="#L8051">8051</a><a id="L8052" href="#L8052">8052</a><a id="L8053" href="#L8053">8053</a><a id="L8054" href="#L8054">8054</a><a id="L8055" href="#L8055">8055</a><a id="L8056" href="#L8056">8056</a><a id="L8057" href="#L8057">8057</a><a id="L8058" href="#L8058">8058</a><a id="L8059" href="#L8059">8059</a><a id="L8060" href="#L8060">8060</a><a id="L8061" href="#L8061">8061</a><a id="L8062" href="#L8062">8062</a><a id="L8063" href="#L8063">8063</a><a id="L8064" href="#L8064">8064</a><a id="L8065" href="#L8065">8065</a><a id="L8066" href="#L8066">8066</a><a id="L8067" href="#L8067">8067</a><a id="L8068" href="#L8068">8068</a><a id="L8069" href="#L8069">8069</a><a id="L8070" href="#L8070">8070</a><a id="L8071" href="#L8071">8071</a><a id="L8072" href="#L8072">8072</a><a id="L8073" href="#L8073">8073</a><a id="L8074" href="#L8074">8074</a><a id="L8075" href="#L8075">8075</a><a id="L8076" href="#L8076">8076</a><a id="L8077" href="#L8077">8077</a><a id="L8078" href="#L8078">8078</a><a id="L8079" href="#L8079">8079</a><a id="L8080" href="#L8080">8080</a><a id="L8081" href="#L8081">8081</a><a id="L8082" href="#L8082">8082</a><a id="L8083" href="#L8083">8083</a><a id="L8084" href="#L8084">8084</a><a id="L8085" href="#L8085">8085</a><a id="L8086" href="#L8086">8086</a><a id="L8087" href="#L8087">8087</a><a id="L8088" href="#L8088">8088</a><a id="L8089" href="#L8089">8089</a><a id="L8090" href="#L8090">8090</a><a id="L8091" href="#L8091">8091</a><a id="L8092" href="#L8092">8092</a><a id="L8093" href="#L8093">8093</a><a id="L8094" href="#L8094">8094</a><a id="L8095" href="#L8095">8095</a><a id="L8096" href="#L8096">8096</a><a id="L8097" href="#L8097">8097</a><a id="L8098" href="#L8098">8098</a><a id="L8099" href="#L8099">8099</a><a id="L8100" href="#L8100">8100</a><a id="L8101" href="#L8101">8101</a><a id="L8102" href="#L8102">8102</a><a id="L8103" href="#L8103">8103</a><a id="L8104" href="#L8104">8104</a><a id="L8105" href="#L8105">8105</a><a id="L8106" href="#L8106">8106</a><a id="L8107" href="#L8107">8107</a><a id="L8108" href="#L8108">8108</a><a id="L8109" href="#L8109">8109</a><a id="L8110" href="#L8110">8110</a><a id="L8111" href="#L8111">8111</a><a id="L8112" href="#L8112">8112</a><a id="L8113" href="#L8113">8113</a><a id="L8114" href="#L8114">8114</a><a id="L8115" href="#L8115">8115</a><a id="L8116" href="#L8116">8116</a><a id="L8117" href="#L8117">8117</a><a id="L8118" href="#L8118">8118</a><a id="L8119" href="#L8119">8119</a><a id="L8120" href="#L8120">8120</a><a id="L8121" href="#L8121">8121</a><a id="L8122" href="#L8122">8122</a><a id="L8123" href="#L8123">8123</a><a id="L8124" href="#L8124">8124</a><a id="L8125" href="#L8125">8125</a><a id="L8126" href="#L8126">8126</a><a id="L8127" href="#L8127">8127</a><a id="L8128" href="#L8128">8128</a><a id="L8129" href="#L8129">8129</a><a id="L8130" href="#L8130">8130</a><a id="L8131" href="#L8131">8131</a><a id="L8132" href="#L8132">8132</a><a id="L8133" href="#L8133">8133</a><a id="L8134" href="#L8134">8134</a><a id="L8135" href="#L8135">8135</a><a id="L8136" href="#L8136">8136</a><a id="L8137" href="#L8137">8137</a><a id="L8138" href="#L8138">8138</a><a id="L8139" href="#L8139">8139</a><a id="L8140" href="#L8140">8140</a><a id="L8141" href="#L8141">8141</a><a id="L8142" href="#L8142">8142</a><a id="L8143" href="#L8143">8143</a><a id="L8144" href="#L8144">8144</a><a id="L8145" href="#L8145">8145</a><a id="L8146" href="#L8146">8146</a><a id="L8147" href="#L8147">8147</a><a id="L8148" href="#L8148">8148</a><a id="L8149" href="#L8149">8149</a><a id="L8150" href="#L8150">8150</a><a id="L8151" href="#L8151">8151</a><a id="L8152" href="#L8152">8152</a><a id="L8153" href="#L8153">8153</a><a id="L8154" href="#L8154">8154</a><a id="L8155" href="#L8155">8155</a><a id="L8156" href="#L8156">8156</a><a id="L8157" href="#L8157">8157</a><a id="L8158" href="#L8158">8158</a><a id="L8159" href="#L8159">8159</a><a id="L8160" href="#L8160">8160</a><a id="L8161" href="#L8161">8161</a><a id="L8162" href="#L8162">8162</a><a id="L8163" href="#L8163">8163</a><a id="L8164" href="#L8164">8164</a><a id="L8165" href="#L8165">8165</a><a id="L8166" href="#L8166">8166</a><a id="L8167" href="#L8167">8167</a><a id="L8168" href="#L8168">8168</a><a id="L8169" href="#L8169">8169</a><a id="L8170" href="#L8170">8170</a><a id="L8171" href="#L8171">8171</a><a id="L8172" href="#L8172">8172</a><a id="L8173" href="#L8173">8173</a><a id="L8174" href="#L8174">8174</a><a id="L8175" href="#L8175">8175</a><a id="L8176" href="#L8176">8176</a><a id="L8177" href="#L8177">8177</a><a id="L8178" href="#L8178">8178</a><a id="L8179" href="#L8179">8179</a><a id="L8180" href="#L8180">8180</a><a id="L8181" href="#L8181">8181</a><a id="L8182" href="#L8182">8182</a><a id="L8183" href="#L8183">8183</a><a id="L8184" href="#L8184">8184</a><a id="L8185" href="#L8185">8185</a><a id="L8186" href="#L8186">8186</a><a id="L8187" href="#L8187">8187</a><a id="L8188" href="#L8188">8188</a><a id="L8189" href="#L8189">8189</a><a id="L8190" href="#L8190">8190</a><a id="L8191" href="#L8191">8191</a><a id="L8192" href="#L8192">8192</a><a id="L8193" href="#L8193">8193</a><a id="L8194" href="#L8194">8194</a><a id="L8195" href="#L8195">8195</a><a id="L8196" href="#L8196">8196</a><a id="L8197" href="#L8197">8197</a><a id="L8198" href="#L8198">8198</a><a id="L8199" href="#L8199">8199</a><a id="L8200" href="#L8200">8200</a><a id="L8201" href="#L8201">8201</a><a id="L8202" href="#L8202">8202</a><a id="L8203" href="#L8203">8203</a><a id="L8204" href="#L8204">8204</a><a id="L8205" href="#L8205">8205</a><a id="L8206" href="#L8206">8206</a><a id="L8207" href="#L8207">8207</a><a id="L8208" href="#L8208">8208</a><a id="L8209" href="#L8209">8209</a><a id="L8210" href="#L8210">8210</a><a id="L8211" href="#L8211">8211</a><a id="L8212" href="#L8212">8212</a><a id="L8213" href="#L8213">8213</a><a id="L8214" href="#L8214">8214</a><a id="L8215" href="#L8215">8215</a><a id="L8216" href="#L8216">8216</a><a id="L8217" href="#L8217">8217</a><a id="L8218" href="#L8218">8218</a><a id="L8219" href="#L8219">8219</a><a id="L8220" href="#L8220">8220</a><a id="L8221" href="#L8221">8221</a><a id="L8222" href="#L8222">8222</a><a id="L8223" href="#L8223">8223</a><a id="L8224" href="#L8224">8224</a><a id="L8225" href="#L8225">8225</a><a id="L8226" href="#L8226">8226</a><a id="L8227" href="#L8227">8227</a><a id="L8228" href="#L8228">8228</a><a id="L8229" href="#L8229">8229</a><a id="L8230" href="#L8230">8230</a><a id="L8231" href="#L8231">8231</a><a id="L8232" href="#L8232">8232</a><a id="L8233" href="#L8233">8233</a><a id="L8234" href="#L8234">8234</a><a id="L8235" href="#L8235">8235</a><a id="L8236" href="#L8236">8236</a><a id="L8237" href="#L8237">8237</a><a id="L8238" href="#L8238">8238</a><a id="L8239" href="#L8239">8239</a><a id="L8240" href="#L8240">8240</a><a id="L8241" href="#L8241">8241</a><a id="L8242" href="#L8242">8242</a><a id="L8243" href="#L8243">8243</a><a id="L8244" href="#L8244">8244</a><a id="L8245" href="#L8245">8245</a><a id="L8246" href="#L8246">8246</a><a id="L8247" href="#L8247">8247</a><a id="L8248" href="#L8248">8248</a><a id="L8249" href="#L8249">8249</a><a id="L8250" href="#L8250">8250</a><a id="L8251" href="#L8251">8251</a><a id="L8252" href="#L8252">8252</a><a id="L8253" href="#L8253">8253</a><a id="L8254" href="#L8254">8254</a><a id="L8255" href="#L8255">8255</a><a id="L8256" href="#L8256">8256</a><a id="L8257" href="#L8257">8257</a><a id="L8258" href="#L8258">8258</a><a id="L8259" href="#L8259">8259</a><a id="L8260" href="#L8260">8260</a><a id="L8261" href="#L8261">8261</a><a id="L8262" href="#L8262">8262</a><a id="L8263" href="#L8263">8263</a><a id="L8264" href="#L8264">8264</a><a id="L8265" href="#L8265">8265</a><a id="L8266" href="#L8266">8266</a><a id="L8267" href="#L8267">8267</a><a id="L8268" href="#L8268">8268</a><a id="L8269" href="#L8269">8269</a><a id="L8270" href="#L8270">8270</a><a id="L8271" href="#L8271">8271</a><a id="L8272" href="#L8272">8272</a><a id="L8273" href="#L8273">8273</a><a id="L8274" href="#L8274">8274</a><a id="L8275" href="#L8275">8275</a><a id="L8276" href="#L8276">8276</a><a id="L8277" href="#L8277">8277</a><a id="L8278" href="#L8278">8278</a><a id="L8279" href="#L8279">8279</a><a id="L8280" href="#L8280">8280</a><a id="L8281" href="#L8281">8281</a><a id="L8282" href="#L8282">8282</a><a id="L8283" href="#L8283">8283</a><a id="L8284" href="#L8284">8284</a><a id="L8285" href="#L8285">8285</a><a id="L8286" href="#L8286">8286</a><a id="L8287" href="#L8287">8287</a><a id="L8288" href="#L8288">8288</a><a id="L8289" href="#L8289">8289</a><a id="L8290" href="#L8290">8290</a><a id="L8291" href="#L8291">8291</a><a id="L8292" href="#L8292">8292</a><a id="L8293" href="#L8293">8293</a><a id="L8294" href="#L8294">8294</a><a id="L8295" href="#L8295">8295</a><a id="L8296" href="#L8296">8296</a><a id="L8297" href="#L8297">8297</a><a id="L8298" href="#L8298">8298</a><a id="L8299" href="#L8299">8299</a><a id="L8300" href="#L8300">8300</a><a id="L8301" href="#L8301">8301</a><a id="L8302" href="#L8302">8302</a><a id="L8303" href="#L8303">8303</a><a id="L8304" href="#L8304">8304</a></td>
<td><td><pre class="sourcecode">
<span class="bc">/******************************************************************************
This module is $(B way) too big!

License:
Copyright (c) 2008 Jarrett Billingsley

This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the
use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:

    1. The origin of this software must not be misrepresented; you must not
	claim that you wrote the original software. If you use this software in a
	product, an acknowledgment in the product documentation would be
	appreciated but is not required.

    2. Altered source versions must be plainly marked as such, and must not
	be misrepresented as being the original software.

    3. This notice may not be removed or altered from any source distribution.
******************************************************************************/</span>

<span class="d Compound"><span class="d Module"><span class="k">module</span> <span class="i">minid</span>.<span class="i">interpreter</span>;</span>

<span class="d Import"><span class="k">import</span> <span class="i">Float</span> = <span class="i">tango</span>.<span class="i">text</span>.<span class="i">convert</span>.<span class="i">Float</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">Integer</span> = <span class="i">tango</span>.<span class="i">text</span>.<span class="i">convert</span>.<span class="i">Integer</span>;</span>

<span class="d Version"><span class="k">version</span>(<span class="i">MDRestrictedCoro</span>) <span class="d Compound">{}</span> <span class="k">else</span>
	<span class="d Import"><span class="k">import</span> <span class="i">tango</span>.<span class="i">core</span>.<span class="i">Thread</span>;</span></span>

<span class="d Import"><span class="k">import</span> <span class="i">tango</span>.<span class="i">core</span>.<span class="i">Traits</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">tango</span>.<span class="i">core</span>.<span class="i">Tuple</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">tango</span>.<span class="i">core</span>.<span class="i">Vararg</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">tango</span>.<span class="i">stdc</span>.<span class="i">string</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">tango</span>.<span class="i">text</span>.<span class="i">Util</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">Utf</span> = <span class="i">tango</span>.<span class="i">text</span>.<span class="i">convert</span>.<span class="i">Utf</span>;</span>

<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">alloc</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">array</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">classobj</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">func</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">gc</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">instance</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">namespace</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">nativeobj</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">opcodes</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">string</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">table</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">thread</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">types</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">utils</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">minid</span>.<span class="i">weakref</span>;</span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Public</span>
<span class="lc">// ================================================================================================================================================</span>

<span class="d Protection"><span class="k">public</span>:

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// VM-related functions</span>

<span class="bc">/**
Push the metatable for the given type.  If the type has no metatable, pushes null.  The type given must be
one of the "normal" types -- the "internal" types are illegal and an error will be thrown.

Params:
	type = The type whose metatable is to be pushed.

Returns:
	The stack index of the newly-pushed value (null if the type has no metatable, or a namespace if it does).
*/</span>
<span class="d Compound"><span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">getTypeMT</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Qualified"><span class="t Identifier"><span class="i">MDValue</span></span>.<span class="t Identifier"><span class="i">Type</span></span></span> <span class="i">type</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Not">!<span class="e Paren">(<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">type</span></span> &gt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">type</span></span> &lt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">WeakRef</span></span></span></span></span>)</span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getTypeMT - Cannot get metatable for type '{}'"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">type</span>))</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ns</span> = <span class="e Index"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">metaTabs</span></span></span>[<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">type</span></span></span>]</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNamespace</span></span>(<span class="i">t</span>, <span class="i">ns</span>)</span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span></span>
}</span></span></span>

<span class="bc">/**
Sets the metatable for the given type to the namespace or null at the top of the stack.  Throws an
error if the type given is one of the "internal" types, or if the value at the top of the stack is
neither null nor a namespace.

Params:
	type = The type whose metatable is to be set.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">setTypeMT</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Qualified"><span class="t Identifier"><span class="i">MDValue</span></span>.<span class="t Identifier"><span class="i">Type</span></span></span> <span class="i">type</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Not">!<span class="e Paren">(<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">type</span></span> &gt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">type</span></span> &lt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">WeakRef</span></span></span></span></span>)</span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setTypeMT - Cannot set metatable for type '{}'"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">type</span>))</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">metaTabs</span></span></span>[<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">type</span></span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mNamespace</span></span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">metaTabs</span></span></span>[<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">type</span></span></span>]</span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setTypeMT - Metatable must be either a namespace or 'null', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Import a module with the given name.  Works just like the import statement in MiniD.  Pushes the
module's namespace onto the stack.

Params:
	name = The name of the module to be imported.

Returns:
	The stack index of the imported module's namespace.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">importModule</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">name</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">importModule</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">insertAndPop</span></span>(<span class="i">t</span>, -<span class="n">2</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Same as above, but uses a name on the stack rather than one provided as a parameter.

Params:
	name = The stack index of the string holding the name of the module to be imported.

Returns:
	The stack index of the imported module's namespace.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">importModule</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">str</span> = <span class="e Call"><span class="e Identifier"><span class="i">getStringObj</span></span>(<span class="i">t</span>, <span class="i">name</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">str</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">name</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"importModule - name must be a 'string', not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">importImpl</span></span>(<span class="i">t</span>, <span class="i">str</span>, <span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>)</span>;</span>

	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes the VM's registry namespace onto the stack.  The registry is sort of a hidden global namespace only accessible
from native code and which native code may use for any purpose.

Returns:
	The stack index of the newly-pushed namespace.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">getRegistry</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNamespace</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">vm</span>.<span class="i">registry</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Allocates a block of memory using the given thread's VM's allocator function.  This memory is $(B not) garbage-collected.
You must free the memory returned by this function in order to avoid memory leaks.

The array returned by this function should not have its length set or be appended to (~=).

Params:
	size = The size, in bytes, of the block to allocate.

Returns:
	A void array representing the memory block.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span><span class="t Array">[]</span> <span class="i">allocMem</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">size</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e TemplateInstance"><span class="i">allocArray</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">void</span></span></span>)</span></span>(<span class="i">size</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Resize a block of memory.  $(B Only call this on memory that has been allocated using the allocMem, _resizeMem or dupMem
functions.)  If you pass this function an empty (0-length) memory block, it will allocate memory.  If you resize an existing
block to a length of 0, it will deallocate that memory.

If you resize a block to a smaller size, its data will be truncated.  If you resize a block to a larger size, the empty
space will be uninitialized.

The array returned by this function through the mem parameter should not have its length set or be appended to (~=).

Params:
	mem = A reference to the memory block you want to reallocate.  This is a reference so that the original memory block
		reference that you pass in is updated.  This can be a 0-length array.

	size = The size, in bytes, of the new size of the memory block.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">resizeMem</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="k">ref</span> <span class="t Integral"><span class="k">void</span></span><span class="t Array">[]</span> <span class="i">mem</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">size</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">resizeArray</span></span></span>(<span class="i">mem</span>, <span class="i">size</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Duplicate a block of memory.  This is safe to call on memory that was not allocated with the thread's VM's allocator.
The new block will be the same size and contain the same data as the old block.

The array returned by this function should not have its length set or be appended to (~=).

Params:
	mem = The block of memory to copy.  This is not required to have been allocated by allocMem, resizeMem, or _dupMem.

Returns:
	The new memory block.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span><span class="t Array">[]</span> <span class="i">dupMem</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">void</span></span><span class="t Array">[]</span> <span class="i">mem</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">dupArray</span></span></span>(<span class="i">mem</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Free a block of memory.  $(B Only call this on memory that has been allocated with allocMem, resizeMem, or dupMem.)
It's legal to free a 0-length block.

Params:
	mem = A reference to the memory block you want to free.  This is a reference so that the original memory block
		reference that you pass in is updated.  This can be a 0-length array.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">freeMem</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="k">ref</span> <span class="t Integral"><span class="k">void</span></span><span class="t Array">[]</span> <span class="i">mem</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">freeArray</span></span></span>(<span class="i">mem</span>)</span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// GC-related stuff</span>

<span class="bc">/**
Runs the garbage collector if necessary.

This will perform a garbage collection only if a sufficient amount of memory has been allocated since
the last collection.

Params:
	t = The thread to use to collect the garbage.  Garbage collection is vm-wide but requires a thread
		in order to be able to call finalization methods.

Returns:
	The number of bytes collected, which may be 0.
*/</span>
<span class="d Protection"><span class="k">public</span> <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">maybeGC</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">ret</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">totalBytes</span></span></span> &gt;= <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">gcLimit</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">ret</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">gc</span></span>(<span class="i">t</span>)</span></span>;</span>

		<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">totalBytes</span></span></span> &gt; <span class="e Paren">(<span class="e RShift"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">gcLimit</span></span></span> &gt;&gt; <span class="e Int"><span class="n">1</span></span></span>)</span></span>)
			<span class="s Expression"><span class="e LShiftAssign"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">gcLimit</span></span></span> &lt;&lt;= <span class="e Int"><span class="n">1</span></span></span>;</span></span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span>
}</span></span></span></span>

<span class="bc">/**
Runs the garbage collector unconditionally.

Params:
	t = The thread to use to collect the garbage.  Garbage collection is vm-wide but requires a thread
		in order to be able to call finalization methods.

Returns:
	The number of bytes collected by this collection cycle.
*/</span>
<span class="d Protection"><span class="k">public</span> <span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">gc</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">beforeSize</span> = <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">totalBytes</span></span></span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">mark</span></span>(<span class="i">t</span>.<span class="i">vm</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">sweep</span></span>(<span class="i">t</span>.<span class="i">vm</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">runFinalizers</span></span>(<span class="i">t</span>)</span>;</span>

	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Identifier"><span class="i">beforeSize</span></span> - <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">totalBytes</span></span></span></span>;</span>
}</span></span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Stack manipulation</span>

<span class="bc">/**
Duplicates a value at the given stack index and pushes it onto the stack.

Params:
	slot = The _slot to duplicate.  Defaults to -1, which means the top of the stack.

Returns:
	The stack index of the newly-pushed _slot.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">dup</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span> = <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">s</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">s</span></span>]</span></span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span>
}</span></span></span>

<span class="bc">/**
Swaps the two values at the given indices.  The first index defaults to the second-from-top
value.  The second index defaults to the top-of-stack.  So, if you call swap with no indices, it will
_swap the top two values.

Params:
	first = The first stack index.
	second = The second stack index.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">swap</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">first</span> = <span class="e Sign">-<span class="e Int"><span class="n">2</span></span></span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">second</span> = <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">first</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">s</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">second</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">f</span></span> == <span class="e Identifier"><span class="i">s</span></span></span>)
		<span class="s Return"><span class="k">return</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tmp</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">f</span></span>]</span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">f</span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">s</span></span>]</span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">s</span></span>]</span> = <span class="e Identifier"><span class="i">tmp</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Inserts the value at the top of the stack into the given _slot, shifting up the values in that _slot
and everything after it up by a _slot.  This means the stack will stay the same size.  Similar to a
"rotate" operation common to many stack machines.

Throws an error if 'slot' corresponds to the 'this' parameter.  'this' can never be modified.

If 'slot' corresponds to the top-of-stack (but not 'this'), this function is a no-op.

Params:
	slot = The _slot in which the value at the top will be inserted.  If this refers to the top of the
		stack, this function does nothing.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">insert</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">s</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">s</span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"insert - Cannot use 'this' as the destination"</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">s</span></span> == <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span></span>)
		<span class="s Return"><span class="k">return</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tmp</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">memmove</span></span>(&amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">s</span> + <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">s</span>], (<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="i">s</span> - <span class="n">1</span>) * <span class="i">MDValue</span>.<span class="i">sizeof</span>)</span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">s</span></span>]</span> = <span class="e Identifier"><span class="i">tmp</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Similar to insert, but combines the insertion with a pop operation that pops everything after the
newly-inserted value off the stack.

Throws an error if 'slot' corresponds to the 'this' parameter.  'this' can never be modified.

If 'slot' corresponds to the top-of-stack (but not 'this'), this function is a no-op.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">insertAndPop</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">s</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">s</span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"insert - Cannot use 'this' as the destination"</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">s</span></span> == <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span></span>)
		<span class="s Return"><span class="k">return</span>;</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">s</span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">s</span></span> + <span class="e Int"><span class="n">1</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
A more generic version of insert.  This allows you to _rotate dist items within the top
numSlots items on the stack.  The top dist items become the bottom dist items within that range
of indices.  So, if the stack looks something like "1 2 3 4 5 6", and you perform a _rotate with
5 slots and a distance of 3, the stack will become "1 4 5 6 2 3".  If the dist parameter is 1,
it behaves just like insert.

Attempting to _rotate more values than there are on the stack (excluding 'this') will throw an error.

If the distance is an even multiple of the number of slots, or if you _rotate 0 or 1 slots, this
function is a no-op.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">rotate</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numSlots</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">dist</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numSlots</span></span> &gt; <span class="e Paren">(<span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>)</span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"rotate - Trying to rotate more values ({}) than can be rotated ({})"</span>, <span class="i">numSlots</span>, <span class="i">stackSize</span>(<span class="i">t</span>) - <span class="n">1</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">numSlots</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Return"><span class="k">return</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">dist</span></span> &gt;= <span class="e Identifier"><span class="i">numSlots</span></span></span>)
		<span class="s Expression"><span class="e ModAssign"><span class="e Identifier"><span class="i">dist</span></span> %= <span class="e Identifier"><span class="i">numSlots</span></span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">dist</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Return"><span class="k">return</span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">dist</span></span> == <span class="e Int"><span class="n">1</span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">insert</span></span>(<span class="i">t</span>, -<span class="i">numSlots</span>)</span>;</span></span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">slots</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Identifier"><span class="i">numSlots</span></span></span> .. <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">dist</span></span> &lt;= <span class="e Int"><span class="n">8</span></span></span>)
	<span class="s Compound">{
		<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Array">[<span class="e Int"><span class="n">8</span></span>]</span> <span class="i">temp</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
		<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">temp</span></span>[<span class="e Int"><span class="n">0</span></span> .. <span class="e Identifier"><span class="i">dist</span></span>]</span> = <span class="e Slice"><span class="e Identifier"><span class="i">slots</span></span>[<span class="e Minus"><span class="e Dollar">$</span> - <span class="e Identifier"><span class="i">dist</span></span></span> .. <span class="e Dollar">$</span>]</span></span>;</span>
		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">numOthers</span> = <span class="e Minus"><span class="e Identifier"><span class="i">numSlots</span></span> - <span class="e Identifier"><span class="i">dist</span></span></span>;</span></span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">memmove</span></span>(&amp;<span class="i">slots</span>[$ - <span class="i">numOthers</span>], &amp;<span class="i">slots</span>[<span class="n">0</span>], <span class="i">numOthers</span> * <span class="i">MDValue</span>.<span class="i">sizeof</span>)</span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">slots</span></span>[<span class="e Int"><span class="n">0</span></span> .. <span class="e Identifier"><span class="i">dist</span></span>]</span> = <span class="e Slice"><span class="e Identifier"><span class="i">temp</span></span>[<span class="e Int"><span class="n">0</span></span> .. <span class="e Identifier"><span class="i">dist</span></span>]</span></span>;</span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">dist</span></span> = <span class="e Minus"><span class="e Identifier"><span class="i">numSlots</span></span> - <span class="e Identifier"><span class="i">dist</span></span></span></span>;</span>
		<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">c</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>

		<span class="s For"><span class="k">for</span>(<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">v</span> = <span class="e Int"><span class="n">0</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Dot"><span class="e Identifier"><span class="i">slots</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>; <span class="e PostIncr"><span class="e Identifier"><span class="i">v</span></span>++</span>)
		<span class="s Compound">{
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i</span> = <span class="e Identifier"><span class="i">v</span></span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">j</span> = <span class="e Plus"><span class="e Identifier"><span class="i">v</span></span> + <span class="e Identifier"><span class="i">dist</span></span></span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tmp</span> = <span class="e Index"><span class="e Identifier"><span class="i">slots</span></span>[<span class="e Identifier"><span class="i">v</span></span>]</span>;</span></span>
			<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">c</span></span>++</span>;</span>

			<span class="s While"><span class="k">while</span>(<span class="e Equal"><span class="e Identifier"><span class="i">j</span></span> != <span class="e Identifier"><span class="i">v</span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">slots</span></span>[<span class="e Identifier"><span class="i">i</span></span>]</span> = <span class="e Index"><span class="e Identifier"><span class="i">slots</span></span>[<span class="e Identifier"><span class="i">j</span></span>]</span></span>;</span>
				<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">i</span></span> = <span class="e Identifier"><span class="i">j</span></span></span>;</span>
				<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">j</span></span> += <span class="e Identifier"><span class="i">dist</span></span></span>;</span>

				<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">j</span></span> &gt;= <span class="e Dot"><span class="e Identifier"><span class="i">slots</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)
					<span class="s Expression"><span class="e MinusAssign"><span class="e Identifier"><span class="i">j</span></span> -= <span class="e Dot"><span class="e Identifier"><span class="i">slots</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span></span>

				<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">c</span></span>++</span>;</span>
			}</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">slots</span></span>[<span class="e Identifier"><span class="i">i</span></span>]</span> = <span class="e Identifier"><span class="i">tmp</span></span></span>;</span>
		}</span></span>
	}</span></span>
}</span></span></span>

<span class="bc">/**
Rotates all stack slots (excluding 'this').  This is the same as calling rotate with a numSlots
parameter of stackSize(_t) - 1.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">rotateAll</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">dist</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">rotate</span></span>(<span class="i">t</span>, <span class="i">stackSize</span>(<span class="i">t</span>) - <span class="n">1</span>, <span class="i">dist</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Pops a number of items off the stack.  Throws an error if you try to _pop more items than there are
on the stack.  'this' is not counted; so if there is 'this' and one value, and you try to _pop 2
values, an error is thrown.

Params:
	n = The number of items to _pop.  Defaults to 1.  Must be greater than 0.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">pop</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">n</span> = <span class="e Int"><span class="n">1</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">n</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"pop - Trying to pop zero items"</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">n</span></span> &gt; <span class="e Paren">(<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Paren">(<span class="e Plus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span>)</span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"pop - Stack underflow"</span>)</span>;</span></span>

	<span class="s Expression"><span class="e MinusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> -= <span class="e Identifier"><span class="i">n</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sets the thread's stack size to an absolute value.  The new stack size must be at least 1 (which
would leave 'this' on the stack and nothing else).  If the new stack size is smaller than the old
one, the old values are simply discarded.  If the new stack size is larger than the old one, the
new slots are filled with null.  Throws an error if you try to set the stack size to 0.

Params:
	newSize = The new stack size.  Must be greater than 0.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">setStackSize</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">newSize</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">newSize</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setStackSize - newSize must be nonzero"</span>)</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">curSize</span> = <span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">newSize</span></span> != <span class="e Identifier"><span class="i">curSize</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span> + <span class="e Identifier"><span class="i">newSize</span></span></span></span>;</span>

		<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">newSize</span></span> &gt; <span class="e Identifier"><span class="i">curSize</span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkStack</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">stackIndex</span>)</span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span> + <span class="e Identifier"><span class="i">curSize</span></span></span> .. <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span>
		}</span></span>
	}</span></span>
}</span></span></span>

<span class="bc">/**
Moves values from one thread to another.  The values are popped off the source thread's stack
and put on the destination thread's stack in the same order that they were on the source stack.

If there are fewer values on the source thread's stack than the number of values, an error will
be thrown in the source thread.

If the two threads belong to different VMs, an error will be thrown in the source thread.

Params:
	src = The thread from which the values will be taken.
	dest = The thread onto whose stack the values will be pushed.
	num = The number of values to transfer.  There must be at least this many values on the source
		thread's stack.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">transferVals</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">src</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">num</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span> !<span class="k">is</span> <span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">src</span>, <span class="sl">"transferVals - Source and destination threads belong to different VMs"</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Equal"><span class="e Identifier"><span class="i">num</span></span> == <span class="e Int"><span class="n">0</span></span></span> || <span class="e Identity"><span class="e Identifier"><span class="i">dest</span></span> <span class="k">is</span> <span class="e Identifier"><span class="i">src</span></span></span></span>)
		<span class="s Return"><span class="k">return</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">src</span>, <span class="i">num</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkStack</span></span>(<span class="i">dest</span>, <span class="i">dest</span>.<span class="i">stackIndex</span> + <span class="i">num</span>)</span>;</span>

	<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> .. <span class="e Plus"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> + <span class="e Identifier"><span class="i">num</span></span></span>]</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Identifier"><span class="i">num</span></span></span> .. <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span>]</span></span>;</span>
	<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> += <span class="e Identifier"><span class="i">num</span></span></span>;</span>
	<span class="s Expression"><span class="e MinusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> -= <span class="e Identifier"><span class="i">num</span></span></span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Pushing values onto the stack</span>

<span class="bc">/**
These push a value of the given type onto the stack.

Returns:
	The stack index of the newly-pushed value.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushNull</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>.<span class="i">nullValue</span>)</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushBool</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">v</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">v</span>))</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushInt</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">v</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">v</span>))</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushFloat</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">mdfloat</span></span> <span class="i">v</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">v</span>))</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushChar</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">v</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">v</span>))</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushString</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">v</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushStringObj</span></span>(<span class="i">t</span>, <span class="i">string</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">v</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Push a formatted string onto the stack.  This works exactly like tango.text.convert.Layout (and in fact
calls it), except that the destination buffer is a MiniD string.

Params:
	fmt = The Tango-style format string.
	... = The arguments to be formatted.

Returns:
	The stack index of the newly-pushed string.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushFormat</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">fmt</span></span>, <span class="o Parameter">...</span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushVFormat</span></span>(<span class="i">t</span>, <span class="i">fmt</span>, <span class="i">_arguments</span>, <span class="i">_argptr</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
A version of pushFormat meant to be called from variadic functions.

Params:
	fmt = The Tango-style format string.
	arguments = The array of TypeInfo for the variadic _arguments.
	argptr = The platform-specific argument pointer.

Returns:
	The stack index of the newly-pushed string.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushVFormat</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">fmt</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">TypeInfo</span></span><span class="t Array">[]</span> <span class="i">arguments</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">va_list</span></span> <span class="i">argptr</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numPieces</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>

	<span class="s Declaration"><span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">sink</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">data</span></span>)</span>
	<span class="s FuncBody"><span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">data</span>)</span>;</span>
		<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">numPieces</span></span>++</span>;</span>
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">data</span></span>.<span class="e Identifier"><span class="i">length</span></span></span>;</span>
	}</span></span></span></span>

	<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">formatter</span></span></span>.<span class="e Identifier"><span class="i">convert</span></span></span>(&amp;<span class="i">sink</span>, <span class="i">arguments</span>, <span class="i">argptr</span>, <span class="i">fmt</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">cat</span></span>(<span class="i">t</span>, <span class="i">numPieces</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Creates a new table object and pushes it onto the stack.

Params:
	size = The number of slots to preallocate in the table, as an optimization.

Returns:
	The stack index of the newly-created table.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">newTable</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">size</span> = <span class="e Int"><span class="n">0</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushTable</span></span>(<span class="i">t</span>, <span class="i">table</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">size</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Creates a new array object and pushes it onto the stack.

Params:
	len = The length of the new array.

Returns:
	The stack index of the newly-created array.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">newArray</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">len</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushArray</span></span>(<span class="i">t</span>, <span class="i">array</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">len</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Creates a new array object using values at the top of the stack.  Pops those values and pushes
the new array onto the stack.

Params:
	len = How many values on the stack to be put into the array, and the length of the resulting
		array.

Returns:
	The stack index of the newly-created array.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">newArrayFromStack</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">len</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="i">len</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">a</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">len</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>[]</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Identifier"><span class="i">len</span></span></span> .. <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span>]</span></span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="i">len</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushArray</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Creates a new native closure and pushes it onto the stack.

If you want to associate upvalues with the function, you should push them in order on
the stack before calling newFunction and then pass how many upvalues you pushed.
An example:

-----
// 1. Push any upvalues.  Here we have two.  Note that they are pushed in order:
// upvalue 0 will be 5 and upvalue 1 will be "hi" once the closure is created.
pushInt(t, 5);
pushString(t, "hi");

// 2. Call newFunction.
newFunction(t, &amp;myFunc, "myFunc", 2);

// 3. Store the resulting closure somewhere.
setGlobal(t, "myFunc");
-----

This function pops any upvalues off the stack and leaves the new closure in their place.

The function's environment is, by default, the current environment (see pushEnvironment).
To use a different environment, see newFunctionWithEnv.

Params:
	func = The native function to be used in the closure.
	name = The _name to be given to the function.  This is just the 'debug' _name that
		shows up in error messages.  In order to make the function accessible, you have
		to actually put the resulting closure somewhere, like in the globals, or in
		a namespace.
	numUpvals = How many upvalues there are on the stack under the _name to be associated
		with this closure.  Defaults to 0.

Returns:
	The stack index of the newly-created closure.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">newFunction</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">NativeFunc</span></span> <span class="i">func</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numUpvals</span> = <span class="e Int"><span class="n">0</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushEnvironment</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">newFunctionWithEnv</span></span>(<span class="i">t</span>, <span class="i">func</span>, <span class="i">name</span>, <span class="i">numUpvals</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Creates a new native closure with an explicit environment and pushes it onto the stack.

Very similar to newFunction, except that it also expects the environment for the function
(a namespace) to be on top of the stack.  Using newFunction's example, one would push
the environment namespace after step 1, and step 2 would call newFunctionWithEnv instead.

Params:
	func = The native function to be used in the closure.
	name = The _name to be given to the function.  This is just the 'debug' _name that
		shows up in error messages.  In order to make the function accessible, you have
		to actually put the resulting closure somewhere, like in the globals, or in
		a namespace.
	numUpvals = How many upvalues there are on the stack under the _name and environment to
		be associated with this closure.  Defaults to 0.

Returns:
	The stack index of the newly-created closure.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">newFunctionWithEnv</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">NativeFunc</span></span> <span class="i">func</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numUpvals</span> = <span class="e Int"><span class="n">0</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="i">numUpvals</span> + <span class="n">1</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">env</span> = <span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">env</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"newFunctionWithEnv - Environment must be a namespace, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Dot"><span class="e ModuleScope">.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">env</span>, <span class="i">string</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">name</span>), <span class="i">func</span>, <span class="i">numUpvals</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">f</span></span>.<span class="e Identifier"><span class="i">nativeUpvals</span></span></span>()</span>[]</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span> - <span class="e Identifier"><span class="i">numUpvals</span></span></span> .. <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="i">numUpvals</span> + <span class="n">1</span>)</span>;</span> <span class="lc">// upvals and env.</span>

	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">f</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Creates a new class and pushes it onto the stack.

After creating the class, you can then fill it with members by using fielda.

Params:
	proto = The stack index of the _base class.  The _base can be `null`, in which case Object (defined
		in the _base library and which lives in the global namespace) will be used.  Otherwise it must
		be a class.

	name = The _name of the class.  Remember that you still have to store the class object somewhere,
		though, like in a global.

Returns:
	The stack index of the newly-created class.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">newClass</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">base</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">b</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Identifier"><span class="i">isNull</span></span>(<span class="i">t</span>, <span class="i">base</span>)</span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushGlobal</span></span>(<span class="i">t</span>, <span class="sl">"Object"</span>)</span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">b</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span></span>;</span>

		<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">b</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"newClass - 'Object' is not a class; it is a '{}'!"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
		}</span></span>

		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, <span class="i">base</span>)</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">b</span></span> = <span class="e Identifier"><span class="i">c</span></span></span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">base</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"newClass - Base must be 'null' or 'class', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushClass</span></span>(<span class="i">t</span>, <span class="i">classobj</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">string</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">name</span>), <span class="i">b</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Same as above, except it uses the global Object as the base.  The new class is left on the
top of the stack.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">newClass</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushGlobal</span></span>(<span class="i">t</span>, <span class="sl">"Object"</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">b</span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">b</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"newClass - 'Object' is not a class; it is a '{}'!"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushClass</span></span>(<span class="i">t</span>, <span class="i">classobj</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">string</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">name</span>), <span class="i">b</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Creates an instance of a class and pushes it onto the stack.  This does $(I not) call any
constructors defined for the class; this simply allocates an instance.

MiniD instances can have two kinds of extra data associated with them for use by the host: extra
MiniD values and arbitrary bytes.  The structure of a MiniD instance is something like this:

-----
// ---------
// |       |
// |       | The data that's part of every instance - its parent class, fields, and finalizer.
// |       |
// +-------+
// |0: "x" | Extra MiniD values which can point into the MiniD heap.
// |1: 5   |
// +-------+
// |...    | Arbitrary byte data.
// ---------
-----

Both extra sections are optional, and no instances created from script classes will have them.

Extra MiniD values are useful for adding "members" to the instance which are not visible to the
scripts but which can still hold MiniD objects.  They will be scanned by the GC, so objects
referenced by these members will not be collected.  If you want to hold a reference to a native
D object, for instance, this would be the place to put it (wrapped in a NativeObject).

The arbitrary bytes associated with an instance are not scanned by either the D or the MiniD GC,
so don'_t store references to GC'ed objects there.  These bytes are useable for just about anything,
such as storing values which can'_t be stored in MiniD values -- structs, complex numbers, long
integers, whatever.

A clarification: You can store references to $(B heap) objects in the extra bytes, but you must not
store references to $(B GC'ed) objects there.  That is, you can 'malloc' some data and store the pointer
in the extra bytes, since that's not GC'ed memory.  You must however perform your own memory management for
such memory.  You can set up a finalizer function for instances in which you can perform memory management
for these references.

Params:
	base = The class from which this instance will be created.
	numValues = How many extra MiniD values will be associated with the instance.  See above.
	extraBytes = How many extra bytes to attach to the instance.  See above.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">newInstance</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">base</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numValues</span> = <span class="e Int"><span class="n">0</span></span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">extraBytes</span> = <span class="e Int"><span class="n">0</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">b</span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, <span class="i">base</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">b</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">base</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"newInstance - expected 'class' for base, not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushInstance</span></span>(<span class="i">t</span>, <span class="i">instance</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">b</span>, <span class="i">numValues</span>, <span class="i">extraBytes</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Creates a new namespace object and pushes it onto the stack.

The parent of the new namespace will be the current function environment, exactly
as in MiniD when you declare a namespace without an explicit parent.

Params:
	name = The _name of the namespace.

Returns:
	The stack index of the newly-created namespace.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">newNamespace</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">newNamespaceNoParent</span></span>(<span class="i">t</span>, <span class="i">name</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, <span class="i">ret</span>)</span>.<span class="e Identifier"><span class="i">parent</span></span></span> = <span class="e Call"><span class="e Identifier"><span class="i">getEnv</span></span>(<span class="i">t</span>)</span></span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span>
}</span></span></span>

<span class="bc">/**
Creates a new namespace object with an explicit parent and pushes it onto the stack.

Params:
	parent = The stack index of the _parent.  The _parent can be null, in which case
		the new namespace will not have a _parent.  Otherwise it must be a namespace.
	name = The _name of the namespace.

Returns:
	The stack index of the newly-created namespace.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">newNamespace</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">parent</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDNamespace</span></span><span class="t Pointer">*</span> <span class="i">p</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Identifier"><span class="i">isNull</span></span>(<span class="i">t</span>, <span class="i">parent</span>)</span>)
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">p</span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ns</span> = <span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, <span class="i">parent</span>)</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">p</span></span> = <span class="e Identifier"><span class="i">ns</span></span></span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">parent</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"newNamespace - Parent must be null or namespace, not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">newNamespaceNoParent</span></span>(<span class="i">t</span>, <span class="i">name</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, <span class="i">ret</span>)</span>.<span class="e Identifier"><span class="i">parent</span></span></span> = <span class="e Identifier"><span class="i">p</span></span></span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span>
}</span></span></span>

<span class="bc">/**
Creates a new namespace object with no parent and pushes it onto the stack.

This is very similar to newNamespace but creates a namespace without a parent.
This function expects no values to be on the stack.

Params:
	name = The _name of the namespace.

Returns:
	The stack index of the newly-created namespace.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">newNamespaceNoParent</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNamespace</span></span>(<span class="i">t</span>, <span class="i">namespace</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">string</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">name</span>), <span class="k">null</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Creates a new thread object (coroutine) and pushes it onto the stack.

Params:
	func = The slot which contains the function to be used as the coroutine's body.
		This can be either a MiniD or native function.

Returns:
	The stack index of the newly-created thread.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">newThread</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">func</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">f</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"newThread - Thread function must be of type 'function', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Version"><span class="k">version</span>(<span class="i">MDRestrictedCoro</span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">f</span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"newThread - Native functions may not be used as the body of a coroutine"</span>)</span>;</span></span>
	}</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushThread</span></span>(<span class="i">t</span>, <span class="i">thread</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">f</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes the given thread onto this thread's stack.

Params:
	o = The thread to push.

Returns:
	The stack index of the newly-pushed value.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushThread</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">o</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes a reference to a native (D) object onto the stack.

Params:
	o = The object to push.

Returns:
	The index of the newly-pushed value.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushNativeObj</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">Object</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">nativeobj</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">o</span>)))</span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes a weak reference to the object at the given stack index onto the stack.  For value types (null,
bool, int, float, and char), weak references are unnecessary, and in these cases the value will simply
be pushed.  Otherwise the pushed value will be a weak reference object.

Params:
	idx = The stack index of the object to get a weak reference of.

Returns:
	The stack index of the newly-pushed value.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushWeakRef</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">idx</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">idx</span>)</span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span>
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Bool</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span>:

			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">dup</span></span>(<span class="i">t</span>, <span class="i">idx</span>)</span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushWeakRefObj</span></span>(<span class="i">t</span>, <span class="i">weakref</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">idx</span>).<span class="i">mBaseObj</span>))</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Stack queries</span>

<span class="bc">/**
Given an index, returns the absolute index that corresponds to it.  This is useful for converting
relative (negative) indices to indices that will never change.  If the index is already absolute,
just returns it.  Throws an error if the index is out of range.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">absIndex</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">idx</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">word</span></span>)<span class="e Identifier"><span class="i">fakeToRel</span></span></span>(<span class="i">t</span>, <span class="i">idx</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if a given stack index (negative or positive) is valid.  Valid positive stack indices range
from [0 .. stackSize(t)$(RPAREN).  Valid negative stack indices range from [-stackSize(t) .. 0$(RPAREN).

*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isValidIndex</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">idx</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &gt;= <span class="e Call"><span class="e Sign">-<span class="e Identifier"><span class="i">stackSize</span></span></span>(<span class="i">t</span>)</span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &lt; <span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span></span>;</span></span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is null.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isNull</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is a bool.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isBool</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Bool</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is an int.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isInt</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is a float.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isFloat</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is an int or a float.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isNum</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">type</span> = <span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>
	<span class="s Return"><span class="k">return</span> <span class="e OrOr"><span class="e Equal"><span class="e Identifier"><span class="i">type</span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span> || <span class="e Equal"><span class="e Identifier"><span class="i">type</span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is a char.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isChar</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is a string.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isString</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is a table.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isTable</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is an array.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isArray</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is a function.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isFunction</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is a class.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isClass</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is an instance.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isInstance</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is a namespace.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isNamespace</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is a thread.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isThread</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Thread</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is a native object.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isNativeObj</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">NativeObj</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the value at the given _slot is a weak reference.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isWeakRef</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">WeakRef</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Gets the truth value of the value at the given _slot.  null, false, integer 0, floating point 0.0,
and character '\0' are considered false; everything else is considered true.  This is the same behavior
as within the language.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isTrue</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">getValue</span></span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>.<span class="e Identifier"><span class="i">isFalse</span></span></span>()</span>;</span>
}</span></span></span>

<span class="bc">/**
Gets the _type of the value at the given _slot.  Value types are given by the MDValue.Type
enumeration defined in minid.types.
*/</span>
<span class="d Function"><span class="t Qualified"><span class="t Identifier"><span class="i">MDValue</span></span>.<span class="t Identifier"><span class="i">Type</span></span></span> <span class="i">type</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>.<span class="e Identifier"><span class="i">type</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Returns the boolean value at the given _slot, or throws an error if it isn'_t one.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">getBool</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Bool</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getBool - expected 'bool' but got '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mBool</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Returns the integer value at the given _slot, or throws an error if it isn'_t one.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">getInt</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getInt - expected 'int' but got '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Returns the float value at the given _slot, or throws an error if it isn'_t one.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">mdfloat</span></span> <span class="i">getFloat</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getFloat - expected 'float' but got '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Returns the numerical value at the given _slot.  This always returns an mdfloat, and will
implicitly cast int values to floats.  Throws an error if the value is neither an int
nor a float.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">mdfloat</span></span> <span class="i">getNum</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getNum - expected 'float' or 'int' but got '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span></span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Returns the character value at the given _slot, or throws an error if it isn'_t one.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">getChar</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getChar - expected 'char' but got '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mChar</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Returns the string value at the given _slot, or throws an error if it isn'_t one.

The returned string points into the MiniD heap.  It should NOT be modified in any way.  The returned
array reference should also not be stored on the D heap, as once the string object is removed from the
MiniD stack, there is no guarantee that the string data will be valid (MiniD might collect it, as it
has no knowledge of the reference held by D).  If you need the string value for a longer period of time,
you should dup it.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">getString</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getString - expected 'string' but got '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mString</span></span></span>.<span class="e Identifier"><span class="i">toString</span></span></span>()</span>;</span>
}</span></span></span>

<span class="bc">/**
Returns the thread object at the given _slot, or throws an error if it isn'_t one.

The returned thread object points into the MiniD heap, and as such, if no reference to it is
held from the MiniD heap or stack, it may be collected, so be sure not to store the reference
away into a D data structure and then let the thread have its references dropped in MiniD.
This is really meant for access to threads so that you can call thread functions on them.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">getThread</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Thread</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getThread - expected 'thread' but got '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mThread</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Returns the native D object at the given _slot, or throws an error if it isn'_t one.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">Object</span></span> <span class="i">getNativeObj</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">NativeObj</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getNativeObj - expected 'nativeobj' but got '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mNativeObj</span></span></span>.<span class="e Identifier"><span class="i">obj</span></span></span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Statements</span>

<span class="bc">/**
An odd sort of protective function.  You can use this function to wrap a call to a library function etc. which
could throw an exception, but when you don't want to have to bother with catching the exception yourself.  Useful
for writing native MiniD libraries.

Say you had a function which opened a file:

-----
File f = OpenFile("filename");
-----

Say this function could throw an exception if it failed.  Since the interpreter can only catch (and make meaningful
stack traces about) exceptions which derive from MDException, any exceptions that this throws would just percolate
up out of the interpreter stack.  You could catch the exception yourself, but that's kind of tedious, especially when
you call a lot of native functions.

Instead, you can wrap the call to this unsafe function with a call to safeCode().

-----
File f = safeCode(t, OpenFile("filename"));
-----

What safeCode() does is it tries to execute the code it is passed.  If it succeeds, it simply returns any value that
the code returns.  If it throws an exception derived from MDException, it rethrows the exception.  And if it throws
an exception that derives from Exception, it throws a new MDException with the original exception's message as the
message.

If you want to wrap statements, you can use a delegate literal:

-----
safeCode(t,
{
	stmt1;
	stmt2;
	stmt3;
}());
-----

Be sure to include those empty parens after the delegate literal, due to the way D converts the expression to a lazy
parameter.  If you don't put the parens there, it will never actually call the delegate.

safeCode() is templated to allow any return value.

Params:
	code = The code to be executed.  This is a lazy parameter, so it's not actually executed until inside the call to
		safeCode.

Returns:
	Whatever the code parameter returns.
*/</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Identifier"><span class="i">T</span></span> <span class="i">safeCode</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">T</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="k">lazy</span> <span class="t Identifier"><span class="i">T</span></span> <span class="i">code</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Try"><span class="s Catch"><span class="k">try</span>
		<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">code</span></span>;</span>
	<span class="k">catch</span>(<span class="o Parameter"><span class="t Identifier"><span class="i">MDException</span></span> <span class="i">e</span></span>)
		<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span></span>
	<span class="s Catch"><span class="k">catch</span>(<span class="o Parameter"><span class="t Identifier"><span class="i">Exception</span></span> <span class="i">e</span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"{}"</span>, <span class="i">e</span>)</span>;</span></span></span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span></span></span>

<span class="bc">/**
This structure is meant to be used as a helper to perform a MiniD-style foreach loop.
It preserves the semantics of the MiniD foreach loop and handles the foreach/opApply protocol
manipulations.

To use this, first you push the container -- what you would normally put on the right side
of the semicolon in a foreach loop in MiniD.  Just like in MiniD, this is one, two, or three
values, and if the first value is not a function, opApply is called on it with the second
value as a user parameter.

Then you can create an instance of this struct using the static opCall and iterate over it
with a D foreach loop.  Instead of getting values as the loop indices, you get indices of
stack slots that hold those values.  You can break out of the loop just as you'd expect,
and you can perform any manipulations you'd like in the loop body.

Example:
-----
// 1. Push the container.  We're just iterating through modules.customLoaders.
lookup(t, "modules.customLoaders");

// 2. Perform a foreach loop on a foreachLoop instance created with the thread and the number
// of items in the container.  We only pushed one value for the container, so we pass 1.
// Note that you must specify the index types (which must all be word), or else D can't infer
// the types for them.

foreach(word k, word v; foreachLoop(t, 1))
{
	// 3. Do whatever you want with k and v.
	pushToString(t, k);
	pushToString(t, v);
	Stdout.formatln("{}: {}", getString(t, -2), getString(t, -1));

	// here we're popping the strings we pushed.  You don't have to pop k and v or anything like that.
	pop(t, 2);
}
-----

Note a few things: the foreach loop will pop the container off the stack, so the above code is
stack-neutral (leaves the stack in the same state it was before it was run).  You don't have to
pop anything inside the foreach loop.  You shouldn't mess with stack values below k and v, since
foreachLoop keeps internal loop data there, but stack indices that were valid before the loop started
will still be accessible.  If you use only one index (like foreach(word v; ...)), it will work just
like in MiniD where an implicit index will be inserted before that one, and you will get the second
indices in v instead of the first.
*/</span>
<span class="d Struct"><span class="k">struct</span> <span class="i">foreachLoop</span>
<span class="d Compound">{
	<span class="d Variables"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span>;</span>
	<span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numSlots</span>;</span>

	<span class="bc">/**
	The struct constructor.

	Params:
		numSlots = How many slots on top of the stack should be interpreted as the container.  Must be
			1, 2, or 3.
	*/</span>
	<span class="d Protection"><span class="k">public</span> <span class="d StorageClass"><span class="k">static</span> <span class="d Function"><span class="t Identifier"><span class="i">foreachLoop</span></span> <span class="i">opCall</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numSlots</span></span>)</span>
	<span class="s FuncBody"><span class="s Compound">{
		<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">foreachLoop</span></span> <span class="i">ret</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">t</span></span></span> = <span class="e Identifier"><span class="i">t</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">numSlots</span></span></span> = <span class="e Identifier"><span class="i">numSlots</span></span></span>;</span>
		<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span>
	}</span></span></span></span></span>

	<span class="bc">/**
	The function that makes everything work.  This is templated to allow any number of indices, but
	the downside to that is that you must specify the types of the indices in the foreach loop that
	iterates over this structure.  All the indices must be of type 'word'.
	*/</span>
	<span class="d Protection"><span class="k">public</span> <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">int</span></span> <span class="i">opApply</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">T</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">T</span></span> <span class="i">dg</span></span>)</span>
	<span class="s FuncBody"><span class="s Compound">{
		<span class="s Declaration"><span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t TemplateInstance"><span class="i">Unique</span>!(<span class="o TemplateArguments"><span class="t TemplateInstance"><span class="i">ParameterTupleOf</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">T</span></span></span>)</span></span>)</span> <span class="i">TypeTest</span>;</span></span></span>
		<span class="s StaticAssert"><span class="k">static</span> <span class="k">assert</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">TypeTest</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> == <span class="e Int"><span class="n">1</span></span></span> &amp;&amp; <span class="e Is"><span class="k">is</span>(<span class="t Identifier"><span class="i">TypeTest</span></span><span class="t Array">[<span class="e Int"><span class="n">0</span></span>]</span> == <span class="t Identifier"><span class="i">word</span></span>)</span></span>, <span class="e String"><span class="sl">"foreachLoop - all indices must be of type 'word'"</span></span>);</span>
		<span class="s Declaration"><span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t TemplateInstance"><span class="i">ParameterTupleOf</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">T</span></span></span>)</span> <span class="i">Indices</span>;</span></span></span>

		<span class="s StaticIf"><span class="k">static</span> <span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">Indices</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> == <span class="e Int"><span class="n">1</span></span></span>)
		<span class="s Compound">{
			<span class="d StorageClass"><span class="k">const</span> <span class="d Variables"><span class="i">numIndices</span> = <span class="e Int"><span class="n">2</span></span>;</span></span>
			<span class="d StorageClass"><span class="k">const</span> <span class="d Variables"><span class="i">numParams</span> = <span class="e Int"><span class="n">1</span></span>;</span></span>
		}</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="d StorageClass"><span class="k">const</span> <span class="d Variables"><span class="i">numIndices</span> = <span class="e Dot"><span class="e Identifier"><span class="i">Indices</span></span>.<span class="e Identifier"><span class="i">length</span></span></span>;</span></span>
			<span class="d StorageClass"><span class="k">const</span> <span class="d Variables"><span class="i">numParams</span> = <span class="e Dot"><span class="e Identifier"><span class="i">Indices</span></span>.<span class="e Identifier"><span class="i">length</span></span></span>;</span></span>
		}</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">numSlots</span></span> &lt; <span class="e Int"><span class="n">1</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">numSlots</span></span> &gt; <span class="e Int"><span class="n">3</span></span></span></span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"foreachLoop - numSlots may only be 1, 2, or 3, not {}"</span>, <span class="i">numSlots</span>)</span>;</span></span>

		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="i">numSlots</span>)</span>;</span>

		<span class="lc">// Make sure we have 3 stack slots for our temp data area</span>
		<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numSlots</span></span> &lt; <span class="e Int"><span class="n">3</span></span></span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">setStackSize</span></span>(<span class="i">t</span>, <span class="i">stackSize</span>(<span class="i">t</span>) + (<span class="n">3</span> - <span class="i">numSlots</span>))</span>;</span></span>

		<span class="lc">// ..and make sure to clean up</span>
		<span class="s ScopeGuard"><span class="k">scope</span>(<span class="i">success</span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="n">3</span>)</span>;</span></span>

		<span class="lc">// Get opApply, if necessary</span>
		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">src</span> = <span class="e Call"><span class="e Identifier"><span class="i">absIndex</span></span>(<span class="i">t</span>, -<span class="n">3</span>)</span>;</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isFunction</span></span></span>(<span class="i">t</span>, <span class="i">src</span>)</span> &amp;&amp; <span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isThread</span></span></span>(<span class="i">t</span>, <span class="i">src</span>)</span></span>)
		<span class="s Compound">{
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">srcObj</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">3</span></span></span>]</span>;</span></span>

			<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">srcObj</span>, <span class="i">MM</span>.<span class="i">Apply</span>, <span class="i">proto</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">srcObj</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"No implementation of {} for type '{}'"</span>, <span class="i">MetaNames</span>[<span class="i">MM</span>.<span class="i">Apply</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>) <span class="s Compound">{}</span> <span class="k">else</span>
			<span class="s Compound">{
				<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span>++</span>;</span>
				<span class="s ScopeGuard"><span class="k">scope</span>(<span class="i">exit</span>) <span class="s Expression"><span class="e PostDecr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span>--</span>;</span></span>
			}</span></span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">method</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">insert</span></span>(<span class="i">t</span>, -<span class="n">4</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">reg</span> = <span class="e Call"><span class="e Identifier"><span class="i">absIndex</span></span>(<span class="i">t</span>, -<span class="n">3</span>)</span>;</span></span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">reg</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">3</span>, <span class="i">callPrologue</span>(<span class="i">t</span>, <span class="i">reg</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">3</span>, <span class="n">2</span>, <span class="i">proto</span>))</span>;</span>

			<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isFunction</span></span></span>(<span class="i">t</span>, <span class="i">src</span>)</span> &amp;&amp; <span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isThread</span></span></span>(<span class="i">t</span>, <span class="i">src</span>)</span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">src</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Invalid iterable type '{}' returned from opApply"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>
		}</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Call"><span class="e Identifier"><span class="i">isThread</span></span>(<span class="i">t</span>, <span class="i">src</span>)</span> &amp;&amp; <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">state</span></span>(<span class="i">getThread</span>(<span class="i">t</span>, <span class="i">src</span>))</span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Initial</span></span></span></span></span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to iterate over a thread that is not in the 'initial' state"</span>)</span>;</span></span>

		<span class="lc">// Set up the indices tuple</span>
		<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">Indices</span></span> <span class="i">idx</span>;</span></span>

		<span class="s StaticIf"><span class="k">static</span> <span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">Indices</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> == <span class="e Int"><span class="n">1</span></span></span>)
			<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">idx</span></span>[<span class="e Int"><span class="n">0</span></span>]</span> = <span class="e Plus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> + <span class="e Int"><span class="n">1</span></span></span></span>;</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="i">i</span></span>, <span class="o Parameter"><span class="i">T</span></span></span>; <span class="e Identifier"><span class="i">Indices</span></span>)
				<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">idx</span></span>[<span class="e Identifier"><span class="i">i</span></span>]</span> = <span class="e Plus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> + <span class="e Identifier"><span class="i">i</span></span></span></span>;</span></span>
		}</span></span>

		<span class="lc">// Do the loop</span>
		<span class="s While"><span class="k">while</span>(<span class="e Bool"><span class="k">true</span></span>)
		<span class="s Compound">{
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">funcReg</span> = <span class="e Call"><span class="e Identifier"><span class="i">dup</span></span>(<span class="i">t</span>, <span class="i">src</span>)</span>;</span></span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">dup</span></span>(<span class="i">t</span>, <span class="i">src</span> + <span class="n">1</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">dup</span></span>(<span class="i">t</span>, <span class="i">src</span> + <span class="n">2</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">rawCall</span></span>(<span class="i">t</span>, <span class="i">funcReg</span>, <span class="i">numIndices</span>)</span>;</span>

			<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Identifier"><span class="i">isFunction</span></span>(<span class="i">t</span>, <span class="i">src</span>)</span>)
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Identifier"><span class="i">isNull</span></span>(<span class="i">t</span>, <span class="i">funcReg</span>)</span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="i">numIndices</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span>
				}</span></span>
			}</span>
			<span class="k">else</span>
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">state</span></span>(<span class="i">getThread</span>(<span class="i">t</span>, <span class="i">src</span>))</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Dead</span></span></span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="i">numIndices</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span>
				}</span></span>
			}</span></span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">dup</span></span>(<span class="i">t</span>, <span class="i">funcReg</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">swap</span></span>(<span class="i">t</span>, <span class="i">src</span> + <span class="n">2</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">dg</span></span>(<span class="i">idx</span>)</span>;</span></span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="i">numIndices</span>)</span>;</span>

			<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">ret</span></span>)
				<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span></span>
		}</span></span>

		<span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">0</span></span>;</span>
	}</span></span></span></span></span></span>
}</span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Exception-related functions</span>

<span class="bc">/**
Throws a MiniD exception using the value at the top of the stack as the exception object.  Any type can
be thrown.  This will throw an actual D exception of type MDException as well, which can be caught in D
as normal ($(B Important:) see catchException for information on catching them).

You cannot use this function if another exception is still in flight, that is, it has not yet been caught with
catchException.  If you try, an Exception will be thrown -- that is, an instance of the D Exception class.

This function obviously does not return.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">throwException</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">isThrowing</span></span></span>)
		<span class="lc">// no, don'_t use throwException.  We want this to be a non-MiniD exception.</span>
		<span class="s Throw"><span class="k">throw</span> <span class="e New"><span class="k">new</span> <span class="t Identifier"><span class="i">Exception</span></span>(<span class="e String"><span class="sl">"throwException - Attempting to throw an exception while one is already in flight"</span></span>)</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwImpl</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
}</span></span></span>

<span class="bc">/**
A shortcut for the very common case where you want to throw a formatted string.  This is equivalent to calling
pushVFormat on the arguments and then calling throwException.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">throwException</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">fmt</span></span>, <span class="o Parameter">...</span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushVFormat</span></span>(<span class="i">t</span>, <span class="i">fmt</span>, <span class="i">_arguments</span>, <span class="i">_argptr</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
When catching MiniD exceptions (those derived from MDException) in D, MiniD doesn'_t know that you've actually caught
one unless you tell it.  If you want to rethrow an exception without seeing what's in it, you can just throw the
D exception object.  But if you want to actually handle the exception, or rethrow it after seeing what's in it,
you $(B must call this function).  This informs MiniD that you have caught the exception that was in flight, and
pushes the exception object onto the stack, where you can inspect it and possibly rethrow it using throwException.

Note that if an exception occurred and you caught it, you might not know anything about what's on the stack.  It
might be garbage from a half-completed operation.  So you might want to store the size of the stack before a 'try'
block, then restore it in the 'catch' block so that the stack will be in a consistent state.

An exception must be in flight for this function to work.  If none is in flight, a MiniD exception is thrown. (For
some reason, that sounds funny.  "Error: there is no error!")

Returns:
	The stack index of the newly-pushed exception object.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">catchException</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Dot"><span class="e Not">!<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">isThrowing</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"catchException - Attempting to catch an exception when none is in flight"</span>)</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">vm</span>.<span class="i">exception</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">exception</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">isThrowing</span></span></span> = <span class="e Bool"><span class="k">false</span></span></span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span>
}</span></span></span>

<span class="bc">/**
After catching an exception, you can get a traceback, which is the sequence of functions that the exception was
thrown through before being caught.  Tracebacks work across coroutine boundaries.  They also work across tailcalls,
and it will be noted when this happens (in the traceback you'll see something like "&lt;4 tailcalls&gt;(?)" to indicate
that 4 tailcalls were performed between the previous function and the next function in the traceback).  Lastly tracebacks
work across native function calls, in which case the name of the function will be noted but no line number will be
given since that would be impossible; instead it is marked as "(native)".

When you call this function, it will push a string representing the traceback onto the given thread's stack, in this
sort of form:

-----
Traceback; function.that.threw.exception(9)
        at function.that.called.it(23)
        at &lt;5 tailcalls&gt;(?)
        at some.native.function(native)
-----

(Due to a DDoc bug, it's actually "Traceback:", not "Traceback;".)

Sometimes you'll get something like "$(LT)no location available$(GT)" in the traceback.  This might happen if some top-level
native API manipulations (that is, those outside the context of any executing function) cause an error.

When you call this function, the traceback information associated with this thread's VM is subsequently erased.  If
this function is called again, you will get an empty string.

Returns:
	The stack index of the newly-pushed traceback string.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">getTraceback</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">traceback</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">""</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">"Traceback: "</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushDebugLocStr</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">vm</span>.<span class="i">traceback</span>[<span class="n">0</span>])</span>;</span>

	<span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="k">ref</span> <span class="i">l</span></span></span>; <span class="e Slice"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">traceback</span></span></span>[<span class="e Int"><span class="n">1</span></span> .. <span class="e Dollar">$</span>]</span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">"\n        at "</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushDebugLocStr</span></span>(<span class="i">t</span>, <span class="i">l</span>)</span>;</span>
	}</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">cat</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">vm</span>.<span class="i">traceback</span>.<span class="i">length</span> * <span class="n">2</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">resizeArray</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">traceback</span>, <span class="n">0</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Variable-related functions</span>

<span class="bc">/**
Sets an upvalue in the currently-executing closure.  The upvalue is set to the value on top of the
stack, which is popped.

This function will fail if called at top-level (that is, outside of any executing closures).

Params:
	idx = The index of the upvalue to set.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">setUpval</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">idx</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setUpval - No function to set upvalue (can't call this function at top level)"</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">upvals</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">nativeUpvals</span></span></span>()</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &gt;= <span class="e Dot"><span class="e Identifier"><span class="i">upvals</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setUpval - Invalid upvalue index ({}, only have {})"</span>, <span class="i">idx</span>, <span class="i">upvals</span>.<span class="i">length</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">upvals</span></span>[<span class="e Identifier"><span class="i">idx</span></span>]</span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">getValue</span></span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span></span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes an upvalue from the currently-executing closure.

This function will fail if called at top-level (that is, outside of any executing closures).

Params:
	idx = The index of the upvalue to set.

Returns:
	The stack index of the newly-pushed value.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">getUpval</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">idx</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getUpval - No function to get upvalue (can't call this function at top level)"</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span>, <span class="e String"><span class="sl">"getUpval used on a non-native func"</span></span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">upvals</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">nativeUpvals</span></span></span>()</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &gt;= <span class="e Dot"><span class="e Identifier"><span class="i">upvals</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getUpval - Invalid upvalue index ({}, only have {})"</span>, <span class="i">idx</span>, <span class="i">upvals</span>.<span class="i">length</span>)</span>;</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">upvals</span>[<span class="i">idx</span>])</span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes the string representation of the type of the value at the given _slot.

Returns:
	The stack index of the newly-pushed string.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushTypeString</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">slot</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes the environment of a closure on the call stack.

Note that if tailcalls have occurred, environments of certain functions will be unavailable, and attempting
to get them will throw an error.

If the _depth you specify if deeper than the call stack, or if there are no functions on the call stack,
the global namespace will be pushed.

Params:
	depth = The _depth into the call stack of the closure whose environment to get.  Defaults to 0, which
		means the currently-executing closure.  A _depth of 1 would mean the closure which called this
		closure, 2 the closure that called that one etc.

Returns:
	The stack index of the newly-pushed environment.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushEnvironment</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">depth</span> = <span class="e Int"><span class="n">0</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNamespace</span></span>(<span class="i">t</span>, <span class="i">getEnv</span>(<span class="i">t</span>, <span class="i">depth</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes a global variable with the given name.  Throws an error if the global cannot be found.

This function respects typical global lookup - that is, it starts at the current
function's environment and goes up the chain.

Params:
	name = The _name of the global to get.

Returns:
	The index of the newly-pushed value.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushGlobal</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">name</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">getGlobal</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Same as pushGlobal, except expects the name of the global to be on top of the stack.  If the value
at the top of the stack is not a string, an error is thrown.  Replaces the name with the value of the
global if found.

Returns:
	The index of the retrieved value (the stack top).
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">getGlobal</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Not">!<span class="e Identifier"><span class="i">v</span></span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getGlobal - Global name must be a string, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">g</span> = <span class="e Call"><span class="e Identifier"><span class="i">lookupGlobal</span></span>(<span class="i">v</span>.<span class="i">mString</span>, <span class="i">getEnv</span>(<span class="i">t</span>))</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">g</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getGlobal - Attempting to get a nonexistent global '{}'"</span>, <span class="i">v</span>.<span class="i">mString</span>.<span class="i">toString</span>())</span>;</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">v</span></span></span> = <span class="e Deref">*<span class="e Identifier"><span class="i">g</span></span></span></span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sets a global variable with the given _name to the value on top of the stack, and pops that value.
Throws an error if the global cannot be found.  Remember that if this is the first time you are
trying to set the global, you have to use newGlobal instead, just like using a global declaration
in MiniD.

This function respects typical global lookup - that is, it starts at the current function's
environment and goes up the chain.

Params:
	name = The _name of the global to set.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">setGlobal</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">name</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">swap</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">setGlobal</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Same as above, but expects the name of the global to be on the stack just below the value to set.
Pops both the name and the value.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">setGlobal</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">2</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, -<span class="n">2</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">n</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">2</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setGlobal - Global name must be a string, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">g</span> = <span class="e Call"><span class="e Identifier"><span class="i">lookupGlobal</span></span>(<span class="i">n</span>.<span class="i">mString</span>, <span class="i">getEnv</span>(<span class="i">t</span>))</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">g</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setGlobal - Attempting to set a nonexistent global '{}'"</span>, <span class="i">n</span>.<span class="i">mString</span>.<span class="i">toString</span>())</span>;</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">g</span></span></span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="n">2</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Declares a global variable with the given _name, sets it to the value on top of the stack, and pops
that value.  Throws an error if the global has already been declared.

This function works just like a global variable declaration in MiniD.  It creates a new entry
in the current environment if it succeeds.

Params:
	name = The _name of the global to set.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">newGlobal</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">name</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">swap</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">newGlobal</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Same as above, but expects the name of the global to be on the stack under the value to be set.  Pops
both the name and the value off the stack.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">newGlobal</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">2</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, -<span class="n">2</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">n</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">2</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"newGlobal - Global name must be a string, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">env</span> = <span class="e Call"><span class="e Identifier"><span class="i">getEnv</span></span>(<span class="i">t</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">contains</span></span></span>(<span class="i">env</span>, <span class="i">n</span>.<span class="i">mString</span>)</span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"newGlobal - Attempting to declare a global '{}' that already exists"</span>, <span class="i">n</span>.<span class="i">mString</span>.<span class="i">toString</span>())</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">set</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">env</span>, <span class="i">n</span>.<span class="i">mString</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="n">2</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Searches for a global of the given _name.

By default, this follows normal global lookup, starting with the currently-executing function's environment,
but you can change where the lookup starts by using the depth parameter.

Params:
	name = The _name of the global to look for.
	depth = The _depth into the call stack of the closure in whose environment lookup should begin.  Defaults
		to 0, which means the currently-executing closure.  A _depth of 1 would mean the closure which called
		this closure, 2 the closure that called that one etc.

Returns:
	true if the global was found, in which case the containing namespace is on the stack.  False otherwise,
	in which case nothing will be on the stack.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">findGlobal</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">depth</span> = <span class="e Int"><span class="n">0</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">n</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">string</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">name</span>)</span>;</span></span>

	<span class="s For"><span class="k">for</span>(<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ns</span> = <span class="e Call"><span class="e Identifier"><span class="i">getEnv</span></span>(<span class="i">t</span>, <span class="i">depth</span>)</span>;</span></span> <span class="e Identity"><span class="e Identifier"><span class="i">ns</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>; <span class="e Assign"><span class="e Identifier"><span class="i">ns</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">ns</span></span>.<span class="e Identifier"><span class="i">parent</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">ns</span>, <span class="i">n</span>)</span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNamespace</span></span>(<span class="i">t</span>, <span class="i">ns</span>)</span>;</span>
			<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span>
		}</span></span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Table-related functions</span>

<span class="bc">/**
Removes all items from the given table object.

Params:
	tab = The stack index of the table object to clear.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">clearTable</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">tab</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tb</span> = <span class="e Call"><span class="e Identifier"><span class="i">getTable</span></span>(<span class="i">t</span>, <span class="i">tab</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">tb</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">tab</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"clearTable - tab must be a table, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">table</span></span>.<span class="e Identifier"><span class="i">clear</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">tb</span>)</span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Array-related functions</span>

<span class="bc">/**
Fills the array at the given index with the value at the top of the stack and pops that value.

Params:
	arr = The stack index of the array object to fill.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">fillArray</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">arr</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">a</span> = <span class="e Call"><span class="e Identifier"><span class="i">getArray</span></span>(<span class="i">t</span>, <span class="i">arr</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">a</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">arr</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"fillArray - arr must be an array, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>[]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Function-related functions</span>

<span class="bc">/**
Pushes the environment namespace of a function closure.

Params:
	func = The stack index of the function whose environment is to be retrieved.

Returns:
	The stack index of the newly-pushed environment namespace.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">getFuncEnv</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">func</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNamespace</span></span>(<span class="i">t</span>, <span class="i">f</span>.<span class="i">environment</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getFuncEnv - Expected 'function', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Sets the namespace at the top of the stack as the environment namespace of a function closure and pops
that namespace off the stack.

Params:
	func = The stack index of the function whose environment is to be set.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">setFuncEnv</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">func</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ns</span> = <span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">ns</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setFuncEnv - Expected 'namespace' for environment, not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">f</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setFuncEnv - Expected 'function', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">f</span></span>.<span class="e Identifier"><span class="i">environment</span></span></span> = <span class="e Identifier"><span class="i">ns</span></span></span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Gets the name of the function at the given stack index.  This is the name given in the declaration
of the function if it's a script function, or the name given to newFunction for native functions.
Some functions, like top-level module functions and nameless function literals, have automatically-
generated names which always start and end with angle brackets ($(LT) and $(GT)).
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">funcName</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">func</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">f</span></span>.<span class="e Identifier"><span class="i">name</span></span></span>.<span class="e Identifier"><span class="i">toString</span></span></span>()</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"funcName - Expected 'function', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Gets the number of parameters that the function at the given stack index takes.  This is the number
of non-variadic arguments, not including 'this'.  For native functions, always returns 0.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">funcNumParams</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">func</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e ModuleScope">.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">numParams</span></span></span>(<span class="i">f</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"funcNumParams - Expected 'function', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Gets whether or not the given function takes variadic arguments.  For native functions, always returns
true.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">funcIsVararg</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">func</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e ModuleScope">.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">isVararg</span></span></span>(<span class="i">f</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"funcIsVararg - Expected 'function', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Gets whether or not the given function is a native function.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">funcIsNative</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">func</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e ModuleScope">.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span>(<span class="i">f</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"funcIsNative - Expected 'function', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Class-related functions</span>

<span class="bc">/**
Sets the finalizer function for the given class.  The finalizer of a class is called when an instance of that class
is about to be collected by the garbage collector and is used to clean up limited resources associated with it
(i.e. memory allocated on the C heap, file handles, etc.).  The finalizer function should be short and to-the-point
as to make finalization as quick as possible.  It should also not allocate very much memory, if any, as the
garbage collector is effectively disabled during execution of finalizers.  The finalizer function will only
ever be called once for each instance.  If the finalizer function causes the instance to be "resurrected", that is
the instance is reattached to the application's memory graph, it will still eventually be collected but its finalizer
function will $(B not) be run again.

Instances get the finalizer from the class that they are an instance of.  If you instantiate a class, and then
change its finalizer, the instances that were already created will use the old finalizer.

This function expects the finalizer function to be on the top of the stack.  If you want to remove the finalizer
function from a class, the value at the top of the stack can be null.

Params:
	cls = The class whose finalizer is to be set.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">setFinalizer</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">cls</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Not">!<span class="e Paren">(<span class="e OrOr"><span class="e Call"><span class="e Identifier"><span class="i">isNull</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span> || <span class="e Call"><span class="e Identifier"><span class="i">isFunction</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span></span>)</span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setFinalizer - Expected 'function' or 'null' for finalizer, not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, <span class="i">cls</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">c</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">cls</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setFinalizer - Expected 'class', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Identifier"><span class="i">isNull</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>)
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">c</span></span>.<span class="e Identifier"><span class="i">finalizer</span></span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">c</span></span>.<span class="e Identifier"><span class="i">finalizer</span></span></span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span></span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes the finalizer function associated with the given class, or null if no finalizer is set for
that class.

Params:
	cls = The class whose finalizer is to be retrieved.

Returns:
	The stack index of the newly-pushed finalizer function (or null if the class has none).
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">getFinalizer</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">cls</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, <span class="i">cls</span>)</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">c</span></span>.<span class="e Identifier"><span class="i">finalizer</span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">c</span>.<span class="i">finalizer</span>)</span>;</span>
		<span class="k">else</span>
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span></span>
	}</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">cls</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getFinalizer - Expected 'class', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Normally when you instantiate a MiniD class, by doing something like "A(5)" (or similarly, by
calling it as if it were a function using the native API), the following happens: the interpreter
calls newInstance on the class to allocate a new instance, then calls any constructor defined for
the class on the new instance with the given parameters, and finally it returns that new instance.

You can override this behavior using class allocators.  A class allocator takes any number of
parameters and must return a class instance.  The 'this' parameter passed to a class allocator is
the class which is being instantiated.  Class allocators reserve the right to call or not
call any constructor defined for the class.  In fact, they can do just about anything as long as
they return an instance.

Here is an example class allocator which performs the default behavior.

-----
uword allocator(MDThread* t, uword numParams)
{
	// new instance of the class held in 'this'
	newInstance(t, 0);

	// duplicate it so it can be used as a return value
	dup(t);

	// push a null for the 'this' slot of the impending method call
	pushNull(t);
	
	// rotate the stack so that we have
	// [inst] [inst] [null] [params...]
	rotateAll(t, 3);

	// call the constructor on the instance, ignoring any returns
	methodCall(t, 2, "constructor", 0);
	
	// now all that's left on the stack is the instance; return it
	return 1;
}
-----

Why would a class use an allocator?  Simple: if it needs to allocate extra values or bytes for
its instances.  Most of the native objects defined in the standard libraries use allocators to
do just this.  

You can also imagine a case where the number of extra values or bytes is dependent upon the
parameters passed to the constructor, which is why class allocators get all the parameters.

This function expects the new class allocator to be on top of the stack.  It should be a function,
or null if you want to remove the given class's allocator.

Params:
	cls = The stack index of the class object whose allocator is to be set.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">setAllocator</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">cls</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Not">!<span class="e Paren">(<span class="e OrOr"><span class="e Call"><span class="e Identifier"><span class="i">isNull</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span> || <span class="e Call"><span class="e Identifier"><span class="i">isFunction</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span></span>)</span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setAllocator - Expected 'function' or 'null' for finalizer, not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, <span class="i">cls</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">c</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">cls</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setAllocator - Expected 'class', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Identifier"><span class="i">isNull</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>)
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">c</span></span>.<span class="e Identifier"><span class="i">allocator</span></span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">c</span></span>.<span class="e Identifier"><span class="i">allocator</span></span></span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span></span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes the allocator associated with the given class, or null if no allocator is set for
that class.

Params:
	cls = The class whose allocator is to be retrieved.

Returns:
	The stack index of the newly-pushed allocator function (or null if the class has none).
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">getAllocator</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">cls</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, <span class="i">cls</span>)</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">c</span></span>.<span class="e Identifier"><span class="i">allocator</span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">c</span>.<span class="i">allocator</span>)</span>;</span>
		<span class="k">else</span>
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span></span>
	}</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">cls</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getAllocator - Expected 'class', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Gets the name of the class at the given stack index.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">className</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">cls</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, <span class="i">cls</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">c</span></span>.<span class="e Identifier"><span class="i">name</span></span></span>.<span class="e Identifier"><span class="i">toString</span></span></span>()</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">cls</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"className - Expected 'class', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Instance-related functions</span>

<span class="bc">/**
Finds out how many extra values an instance has (see newInstance for info on that).  Throws an error
if the value at the given _slot isn'_t an instance.

Params:
	slot = The stack index of the instance whose number of values is to be retrieved.

Returns:
	The number of extra values associated with the given instance.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numExtraVals</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i</span> = <span class="e Call"><span class="e Identifier"><span class="i">getInstance</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">numValues</span></span></span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"numExtraVals - expected 'instance' but got '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes the idx th extra value from the instance at the given _slot.  Throws an error if the value at
the given _slot isn'_t an instance, or if the index is out of bounds.

Params:
	slot = The instance whose value is to be retrieved.
	idx = The index of the extra value to get.

Returns:
	The stack index of the newly-pushed value.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">getExtraVal</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">idx</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i</span> = <span class="e Call"><span class="e Identifier"><span class="i">getInstance</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &gt;= <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">numValues</span></span></span></span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getExtraVal - Value index out of bounds ({}, but only have {})"</span>, <span class="i">idx</span>, <span class="i">i</span>.<span class="i">numValues</span>)</span>;</span></span>

		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">i</span>.<span class="i">extraValues</span>()[<span class="i">idx</span>])</span>;</span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getExtraVal - expected 'instance' but got '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>
		
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Pops the value off the top of the stack and places it in the idx th extra value in the instance at the
given _slot.  Throws an error if the value at the given _slot isn'_t an instance, or if the index is out
of bounds.

Params:
	slot = The instance whose value is to be set.
	idx = The index of the extra value to set.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">setExtraVal</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">idx</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i</span> = <span class="e Call"><span class="e Identifier"><span class="i">getInstance</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &gt; <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">numValues</span></span></span></span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setExtraVal - Value index out of bounds ({}, but only have {})"</span>, <span class="i">idx</span>, <span class="i">i</span>.<span class="i">numValues</span>)</span>;</span></span>

		<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">extraValues</span></span></span>()</span>[<span class="e Identifier"><span class="i">idx</span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setExtraVal - expected 'instance' but got '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>
}</span></span></span>

<span class="bc">/**
Gets a void array of the extra bytes associated with the instance at the given _slot.  If the instance has
no extra bytes, returns null.  Throws an error if the value at the given _slot isn'_t an instance.

The returned void array points into the MiniD heap, so you should not store the returned reference
anywhere.

Params:
	slot = The instance whose data is to be retrieved.

Returns:
	A void array of the data, or null if the instance has none.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span><span class="t Array">[]</span> <span class="i">getExtraBytes</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i</span> = <span class="e Call"><span class="e Identifier"><span class="i">getInstance</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">extraBytes</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span>

		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">extraData</span></span></span>()</span>;</span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getExtraBytes - expected 'instance' but got '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>
		
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Namespace-related functions</span>

<span class="bc">/**
Removes all items from the given namespace object.

Params:
	ns = The stack index of the namespace object to clear.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">clearNamespace</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">ns</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, <span class="i">ns</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">n</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">ns</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"clearNamespace - ns must be a namespace, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">clear</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">n</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Removes the key value at the top of the stack from the given object.  The key value
is popped.  The object must be a namespace or table.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">removeKey</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">obj</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tab</span> = <span class="e Call"><span class="e Identifier"><span class="i">getTable</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTable</span></span>(<span class="i">t</span>, <span class="i">tab</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">dup</span></span>(<span class="i">t</span>, -<span class="n">2</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">idxa</span></span>(<span class="i">t</span>, -<span class="n">3</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="n">2</span>)</span>;</span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ns</span> = <span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isString</span></span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"removeKey - key must be a string, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
		}</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">opin</span></span></span>(<span class="i">t</span>, -<span class="n">1</span>, <span class="i">obj</span>)</span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushToString</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"removeKey - key '{}' does not exist in namespace '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
		}</span></span>

		<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">remove</span></span></span>(<span class="i">ns</span>, <span class="i">getStringObj</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"removeKey - obj must be a namespace or table, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span></span>
}</span></span></span>

<span class="bc">/**
Gets the name of the namespace at the given stack index.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">namespaceName</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">ns</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, <span class="i">ns</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">n</span></span>.<span class="e Identifier"><span class="i">name</span></span></span>.<span class="e Identifier"><span class="i">toString</span></span></span>()</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">ns</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"namespaceName - Expected 'namespace', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes the "full" name of the given namespace, which includes all the parent namespace name components,
separated by dots.

Returns:
	The stack index of the newly-pushed name string.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">namespaceFullname</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">ns</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, <span class="i">ns</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNamespaceNamestring</span></span>(<span class="i">t</span>, <span class="i">n</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">ns</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"namespaceFullname - Expected 'namespace', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Thread-specific stuff</span>

<span class="bc">/**
Gets the current coroutine _state of the thread as a member of the MDThread.State enumeration.
*/</span>
<span class="d Function"><span class="t Qualified"><span class="t Identifier"><span class="i">MDThread</span></span>.<span class="t Identifier"><span class="i">State</span></span></span> <span class="i">state</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Gets a string representation of the current coroutine state of the thread.

The string returned is not on the MiniD heap, it's just a string literal.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">stateString</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">StateStrings</span></span></span>[<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span>]</span>;</span>
}</span></span></span>

<span class="bc">/**
Gets the VM that the thread is associated with.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">MDVM</span></span><span class="t Pointer">*</span> <span class="i">getVM</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Find how many calls deep the currently-executing function is nested.  Tailcalls are taken into account.

If called at top-level, returns 0.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">callDepth</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">depth</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>

	<span class="s For"><span class="k">for</span>(<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">i</span> = <span class="e Int"><span class="n">0</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">i</span></span> &lt; <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span></span>; <span class="e PostIncr"><span class="e Identifier"><span class="i">i</span></span>++</span>)
		<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">depth</span></span> += <span class="e Plus"><span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">actRecs</span></span></span>[<span class="e Identifier"><span class="i">i</span></span>]</span>.<span class="e Identifier"><span class="i">numTailcalls</span></span></span> + <span class="e Int"><span class="n">1</span></span></span></span>;</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">depth</span></span>;</span>
}</span></span></span>

<span class="bc">/**
Returns the number of items on the stack.  Valid positive stack indices range from [0 .. _stackSize(t)$(RPAREN).
Valid negative stack indices range from [-_stackSize(t) .. 0$(RPAREN).

Note that 'this' (stack index 0 or -_stackSize(t)) may not be overwritten or changed, although it can be used
with functions that don'_t modify their argument.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">stackSize</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> &gt; <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span></span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Resets a dead thread to the initial state, optionally providing a new function to act as the body of the thread.

Params:
	slot = The stack index of the thread to be reset.  It must be in the 'dead' state.
	newFunction = If true, a function should be on top of the stack which should serve as the new body of the
		coroutine.  The default is false, in which case the coroutine will use the function with which it was
		created.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">resetThread</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">newFunction</span> = <span class="e Bool"><span class="k">false</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">other</span> = <span class="e Call"><span class="e Identifier"><span class="i">getThread</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">other</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"resetThread - Object at 'slot' must be a 'thread', not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">state</span></span>(<span class="i">other</span>)</span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Dead</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"resetThread - Attempting to reset a {} coroutine (must be dead)"</span>, <span class="i">stateString</span>(<span class="i">other</span>))</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">newFunction</span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>

		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">f</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"resetThread - Attempting to reset a coroutine with a '{}' instead of a 'function'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
		}</span></span>

		<span class="s Version"><span class="k">version</span>(<span class="i">MDRestrictedCoro</span>)
		<span class="s Compound">{
			<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">f</span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"resetThread - Native functions may not be used as the body of a coroutine"</span>)</span>;</span></span>
		}</span></span>

		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">other</span></span>.<span class="e Identifier"><span class="i">coroFunc</span></span></span> = <span class="e Identifier"><span class="i">f</span></span></span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
	}</span></span>

	<span class="s Version"><span class="k">version</span>(<span class="i">MDRestrictedCoro</span>) <span class="s Compound">{}</span> <span class="k">else</span>
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">other</span></span>.<span class="e Identifier"><span class="i">coroFiber</span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">other</span></span>.<span class="e Identifier"><span class="i">getFiber</span></span></span>()</span>.<span class="e Identifier"><span class="i">state</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">Fiber</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">TERM</span></span></span></span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">other</span></span>.<span class="e Identifier"><span class="i">getFiber</span></span></span>()</span>.<span class="e Identifier"><span class="i">reset</span></span></span>()</span>;</span>
		}</span></span>
	}</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">other</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Initial</span></span></span></span>;</span>
}</span></span></span>

<span class="d Version"><span class="k">version</span>(<span class="i">MDRestrictedCoro</span>) <span class="d Compound">{}</span> <span class="k">else</span>
<span class="d Compound">{
	<span class="bc">/**
	Yield out of a coroutine.  This function is not available in restricted coroutine mode, and in normal coroutine
	mode, it will only work when yielding out of a native coroutine (one with a native function as its body).  In
	extended mode, it will always work.

	You cannot _yield out of a thread that is not currently executing, nor can you _yield out of the main thread of
	a VM.
	
	This function works very similarly to the call family of functions.  You push the values that you want to _yield
	on the stack, then pass how many you pushed and how many you want back.  It then returns how many values this
	coroutine was resumed with, and that many values will be on the stack.

	Example:
-----
// Let's translate `x = yield(5, "hi")` into API calls.

// 1. Push the values to be yielded.
pushInt(t, 5);
pushString(t, "hi");

// 2. Yield from the coroutine, telling that we are yielding 2 values and want 1 in return.
yield(t, 2, 1);

// 3. Do something with the return value.  setGlobal pops the return value off the stack, so now the
// stack is back the way it was when we started.
setGlobal(t, "x");
-----

	Params:
		numVals = The number of values that you are yielding.  These values should be on top of the stack, in order.
		numReturns = The number of return values you are expecting, or -1 for as many returns as you can get.

	Returns:
		How many values were returned.  If numReturns was &gt;= 0, this is the same as numReturns.
	*/</span>
	<span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">yield</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numVals</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numReturns</span></span>)</span>
	<span class="s FuncBody"><span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="i">numVals</span>)</span>;</span>

		<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">t</span></span> <span class="k">is</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">mainThread</span></span></span></span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"yield - Attempting to yield out of the main thread"</span>)</span>;</span></span>

		<span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>) <span class="s Compound">{}</span> <span class="k">else</span>
		<span class="s Compound">{
			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">coroFiber</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"yield - Attempting to yield out of a script coroutine"</span>)</span>;</span></span>
		}</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">Fiber</span></span>.<span class="e Identifier"><span class="i">getThis</span></span></span>()</span> !<span class="k">is</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">getFiber</span></span></span>()</span></span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"yield - Attempting to yield the wrong thread"</span>)</span>;</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numReturns</span></span> &lt; <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"yield - invalid number of returns (must be &gt;= -1)"</span>)</span>;</span></span>

		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">slot</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Identifier"><span class="i">numVals</span></span></span>;</span></span>

		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">yieldImpl</span></span>(<span class="i">t</span>, <span class="i">slot</span>, <span class="i">numReturns</span>, <span class="i">numVals</span>)</span>;</span>

		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">numReturns</span></span> == <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Identifier"><span class="i">slot</span></span></span>;</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Identifier"><span class="i">numReturns</span></span></span></span>;</span>
			<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">numReturns</span></span>;</span>
		}</span></span>
	}</span></span></span>
}</span></span>

<span class="bc">/**
Halts the given thread.  If the given thread is currently running, throws a halt exception immediately;
otherwise, places a pending halt on the thread.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">haltThread</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">state</span></span>(<span class="i">t</span>)</span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Running</span></span></span></span>)
		<span class="s Throw"><span class="k">throw</span> <span class="e New"><span class="k">new</span> <span class="t Identifier"><span class="i">MDHaltException</span></span>()</span>;</span>
	<span class="k">else</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pendingHalt</span></span>(<span class="i">t</span>)</span>;</span></span>
}</span></span></span>

<span class="bc">/**
Places a pending halt on the thread.  This does nothing if the thread is in the 'dead' state.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">pendingHalt</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">state</span></span>(<span class="i">t</span>)</span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Dead</span></span></span></span> &amp;&amp; <span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">shouldHalt</span></span></span> = <span class="e Bool"><span class="k">true</span></span></span>;</span></span>
}</span></span></span>

<span class="bc">/**
Sees if the given thread has a pending halt.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">hasPendingHalt</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">shouldHalt</span></span></span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Weakref-related functions</span>

<span class="bc">/**
Works like the deref() function in the base library.  If the value at the given index is a
value type, just duplicates that value.  If the value at the given index is a weak reference,
pushes the object it refers to or 'null' if that object has been collected.  Throws an error
if the value at the given index is any other type.  This is meant to be an inverse to pushWeakRef,
hence the behavior with regards to value types.

Params:
	idx = The stack index of the object to dereference.

Returns:
	The stack index of the newly-pushed value.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">deref</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">idx</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Call"><span class="e Identifier"><span class="i">type</span></span>(<span class="i">t</span>, <span class="i">idx</span>)</span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span>
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Bool</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span>:

			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">dup</span></span>(<span class="i">t</span>, <span class="i">idx</span>)</span>;</span></span></span></span>
			
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">WeakRef</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">o</span> = <span class="e Dot"><span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, <span class="i">idx</span>)</span>.<span class="e Identifier"><span class="i">mWeakRef</span></span></span>.<span class="e Identifier"><span class="i">obj</span></span></span></span></span></span>)
				<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">o</span>))</span>;</span>
			<span class="k">else</span>
				<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span></span></span></span></span>
				
		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">idx</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"deref - idx must be a value type or weakref, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span></span></span></span>
	}</span></span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Atomic MiniD operations</span>

<span class="bc">/**
Push a string representation of any MiniD value onto the stack.

Params:
	slot = The stack index of the value to convert to a string.
	raw = If true, will not call toString metamethods.  Defaults to false, which means toString
		metamethods will be called.

Returns:
	The stack index of the newly-pushed string.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushToString</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span> = <span class="e Bool"><span class="k">false</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="lc">// Dereferencing so that we don'_t potentially push an invalid stack object.</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">getValue</span></span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">toStringImpl</span></span>(<span class="i">t</span>, <span class="i">v</span>, <span class="i">raw</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
See if item is in container.  Works like the MiniD 'in' operator.  Calls opIn metamethods.

Params:
	item = The _item to look for (the lhs of 'in').
	container = The _object in which to look (the rhs of 'in').

Returns:
	true if item is in container, false otherwise.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">opin</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">item</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">container</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">inImpl</span></span>(<span class="i">t</span>, <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">item</span>), <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">container</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Compare two values at the given indices, and give the comparison value (negative for a &lt; b, positive for a &gt; b,
and 0 if a == b).  This is the exact behavior of the '&lt;=&gt;' operator in MiniD.  Calls opCmp metamethods.

Params:
	a = The index of the first object.
	b = The index of the second object.

Returns:
	The comparison value.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">cmp</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">compareImpl</span></span>(<span class="i">t</span>, <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">a</span>), <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">b</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Test two values at the given indices for equality.  This is the exact behavior of the '==' operator in MiniD.
Calls opEquals metamethods.

Params:
	a = The index of the first object.
	b = The index of the second object.

Returns:
	true if equal, false otherwise.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">equals</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">equalsImpl</span></span>(<span class="i">t</span>, <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">a</span>), <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">b</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Test two values at the given indices for identity.  This is the exact behavior of the 'is' operator in MiniD.

Params:
	a = The index of the first object.
	b = The index of the second object.

Returns:
	true if identical, false otherwise.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">opis</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Call"><span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">bool</span></span>)<span class="e Identifier"><span class="i">getValue</span></span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>.<span class="e Identifier"><span class="i">opEquals</span></span></span>(*<span class="i">getValue</span>(<span class="i">t</span>, <span class="i">b</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Index the _container at the given index with the value at the top of the stack.  Replaces the value on the
stack with the result.  Calls opIndex metamethods.

-----
// x = a[6]
auto cont = pushGlobal(t, "a");
pushInt(t, 6);
idx(t, cont);
setGlobal(t, "x");
pop(t);
// The stack is how it was when we started.
-----

Params:
	container = The stack index of the _container object.
	raw = If true, no opIndex metamethods will be called.  Defaults to false.

Returns:
	The stack index that contains the result (the top of the stack).
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">idx</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span> = <span class="e Bool"><span class="k">false</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">slot</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">idxImpl</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>], <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">container</span>), &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>], <span class="i">raw</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Index-assign the _container at the given index with the key at the second-from-top of the stack and the
value at the top of the stack.  Pops both the key and the value from the stack.  Calls opIndexAssign
metamethods.

-----
// a[6] = 10
auto cont = pushGlobal(t, "a");
pushInt(t, 6);
pushInt(t, 10);
idxa(t, cont);
pop(t);
// The stack is how it was when we started.
-----

Params:
	container = The stack index of the _container object.
	raw = If true, no opIndex metamethods will be called.  Defaults to false.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">idxa</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span> = <span class="e Bool"><span class="k">false</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">2</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">slot</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">2</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">idxaImpl</span></span>(<span class="i">t</span>, <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">container</span>), &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span> + <span class="n">1</span>], <span class="i">raw</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="n">2</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Shortcut for the common case where you need to index a _container with an integer index.  Pushes
the indexed value.

Params:
	container = The stack index of the _container object.
	idx = The integer index.
	raw = If true, no opIndex metamethods will be called.  Defaults to false.

Returns:
	The stack index of the newly-pushed indexed value.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">idxi</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">idx</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span> = <span class="e Bool"><span class="k">false</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">absIndex</span></span>(<span class="i">t</span>, <span class="i">container</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushInt</span></span>(<span class="i">t</span>, <span class="i">idx</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e ModuleScope">.<span class="e Identifier"><span class="i">idx</span></span></span>(<span class="i">t</span>, <span class="i">c</span>, <span class="i">raw</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Shortcut for the common case where you need to index-assign a _container with an integer index.  Pops
the value at the top of the stack and assigns it into the _container at the given index.

Params:
	container = The stack index of the _container object.
	idx = The integer index.
	raw = If true, no opIndexAssign metamethods will be called.  Defaults to false.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">idxai</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">idx</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span> = <span class="e Bool"><span class="k">false</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">absIndex</span></span>(<span class="i">t</span>, <span class="i">container</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushInt</span></span>(<span class="i">t</span>, <span class="i">idx</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">swap</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">idxa</span></span>(<span class="i">t</span>, <span class="i">c</span>, <span class="i">raw</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Get a _field with the given _name from the _container at the given index.  Pushes the result onto the stack.

-----
// x = a.y
pushGlobal(t, "a");
field(t, -1, "y");
setGlobal(t, "x");
pop(t);
// The stack is how it was when we started.
-----

Params:
	container = The stack index of the _container object.
	name = The _name of the _field to get.
	raw = If true, does not call opField metamethods.  Defaults to false, which means it will.

Returns:
	The stack index of the newly-pushed result.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">field</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span> = <span class="e Bool"><span class="k">false</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">container</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">name</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonField</span></span>(<span class="i">t</span>, <span class="i">c</span>, <span class="i">raw</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Same as above, but expects the _field name to be at the top of the stack.  If the value at the top of the
stack is not a string, an error is thrown.  The _field value replaces the _field name, much like with idx.

Params:
	container = The stack index of the _container object.
	raw = If true, does not call opField metamethods.  Defaults to false, which means it will.

Returns:
	The stack index of the retrieved _field value.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">field</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span> = <span class="e Bool"><span class="k">false</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isString</span></span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"field - Field name must be a string, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonField</span></span>(<span class="i">t</span>, <span class="i">fakeToAbs</span>(<span class="i">t</span>, <span class="i">container</span>), <span class="i">raw</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Sets a field with the given _name in the _container at the given index to the value at the top of the stack.
Pops that value off the stack.  Calls opFieldAssign metamethods.

-----
// a.y = x
auto cont = pushGlobal(t, "a");
pushGlobal(t, "x");
fielda(t, cont, "y");
pop(t);
// The stack is how it was when we started.
-----

Params:
	container = The stack index of the _container object.
	name = The _name of the field to set.
	raw = If true, does not call opFieldAssign metamethods.  Defaults to false, which means it will.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">fielda</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span> = <span class="e Bool"><span class="k">false</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">container</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">name</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">swap</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">commonFielda</span></span>(<span class="i">t</span>, <span class="i">c</span>, <span class="i">raw</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Same as above, but expects the field name to be in the second-from-top slot and the value to set at the top of
the stack, similar to idxa.  Throws an error if the field name is not a string.  Pops both the set value and the
field name off the stack, just like idxa.

Params:
	container = The stack index of the _container object.
	raw = If true, does not call opFieldAssign metamethods.  Defaults to false, which means it will.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">fielda</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span> = <span class="e Bool"><span class="k">false</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">2</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isString</span></span></span>(<span class="i">t</span>, -<span class="n">2</span>)</span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">2</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"fielda - Field name must be a string, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">commonFielda</span></span>(<span class="i">t</span>, <span class="i">fakeToAbs</span>(<span class="i">t</span>, <span class="i">container</span>), <span class="i">raw</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Pushes the length of the object at the given _slot.  Calls opLength metamethods.

Params:
	slot = The _slot of the object whose length is to be retrieved.

Returns:
	The stack index of the newly-pushed length.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushLen</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">o</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">lenImpl</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">o</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Gets the integral length of the object at the given _slot.  Calls opLength metamethods.  If the length
of the object is not an integer, throws an error.

Params:
	slot = The _slot of the object whose length is to be retrieved.

Returns:
	The length of the object.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">len</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushLen</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isInt</span></span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"len - Expected length to be an int, but got '{}' instead"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">getInt</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span>
}</span></span></span>

<span class="bc">/**
Sets the length of the object at the given _slot to the value at the top of the stack and pops that
value.  Calls opLengthAssign metamethods.

Params:
	slot = The _slot of the object whose length is to be set.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">lena</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">o</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">lenaImpl</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">o</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Slice the object at the given slot.  The low index is the second-from-top value on the stack, and
the high index is the top value.  Either index can be null.  The indices are popped and the result
of the _slice operation is pushed.

Params:
	container = The slot of the object to be sliced.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slice</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">container</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">2</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">slot</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">2</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">sliceImpl</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>], <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">container</span>), &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span> + <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Slice-assign the object at the given slot.  The low index is the third-from-top value; the high is
the second-from-top; and the value to assign into the object is on the top.  Either index can be null.
Both indices and the value are popped.

Params:
	container = The slot of the object to be slice-assigned.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">slicea</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">container</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">3</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">slot</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">3</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">sliceaImpl</span></span>(<span class="i">t</span>, <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">container</span>), &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span> + <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span> + <span class="n">2</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="n">3</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
These all perform the given mathematical operation on the two values at the given indices, and push
the result of that operation onto the stack.  Metamethods (including reverse versions) will be called.

Don'_t use these functions if you're looking to do some serious number crunching on ints and floats.  Just
get the values and do the computation in D.

Params:
	a = The slot of the first value.
	b = The slot of the second value.

Returns:
	The stack index of the newly-pushed result.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">add</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">aslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">b</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Add</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">aslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">bslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">sub</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">aslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">b</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Sub</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">aslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">bslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">mul</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">aslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">b</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Mul</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">aslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">bslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">div</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">aslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">b</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Div</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">aslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">bslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">mod</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">aslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">b</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Mod</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">aslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">bslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Negates the value at the given index and pushes the result.  Calls opNeg metamethods.

Like the binary operations, don'_t use this unless you need the actual MiniD semantics, as it's
less efficient than just getting a number and negating it.

Params:
	o = The slot of the value to negate.

Returns:
	The stack index of the newly-pushed result.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">neg</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">negImpl</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
These all perform the given reflexive mathematical operation on the value at the given slot, using
the value at the top of the stack for the rhs.  The rhs is popped.  These call metamethods.

Like the other mathematical methods, it's more efficient to perform the operation directly on numbers
rather than to use these methods.  Use these only if you need the MiniD semantics.

Params:
	o = The slot of the object to perform the reflexive operation on.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">addeq</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">AddEq</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">subeq</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">SubEq</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">muleq</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">MulEq</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">diveq</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">DivEq</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">modeq</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">ModEq</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
These all perform the given bitwise operation on the two values at the given indices, _and push
the result of that operation onto the stack.  Metamethods (including reverse versions) will be called.

Don'_t use these functions if you're looking to do some serious number crunching on ints.  Just
get the values _and do the computation in D.

Params:
	a = The slot of the first value.
	b = The slot of the second value.

Returns:
	The stack index of the newly-pushed result.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">and</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">aslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">b</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">And</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">aslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">bslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">or</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">aslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">b</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Or</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">aslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">bslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">xor</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">aslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">b</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Xor</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">aslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">bslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">shl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">aslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">b</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Shl</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">aslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">bslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">shr</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">aslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">b</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Shr</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">aslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">bslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">ushr</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">aslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">b</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">UShr</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">aslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">bslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Bitwise complements the value at the given index and pushes the result.  Calls opCom metamethods.

Like the binary operations, don'_t use this unless you need the actual MiniD semantics, as it's
less efficient than just getting a number and complementing it.

Params:
	o = The slot of the value to complement.
	
Returns:
	The stack index of the newly-pushed result.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">com</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">comImpl</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>])</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
These all perform the given reflexive bitwise operation on the value at the given slot, using
the value at the top of the stack for the rhs.  The rhs is popped.  These call metamethods.

Like the other bitwise methods, it's more efficient to perform the operation directly on numbers
rather than to use these methods.  Use these only if you need the MiniD semantics.

Params:
	o = The slot of the object to perform the reflexive operation on.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">andeq</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">AndEq</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">oreq</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">OrEq</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">xoreq</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">XorEq</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">shleq</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">ShlEq</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">shreq</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">ShrEq</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="lc">/// ditto</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">ushreq</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oslot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">o</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">UShrEq</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">oslot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">t</span>.<span class="i">stackIndex</span> - <span class="n">1</span>])</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Concatenates the top num parameters on the stack, popping them all and pushing the result on the stack.

If num is 1, this function does nothing.  If num is 0, it is an error.  Otherwise, the concatenation
works just like it does in MiniD.

-----
// x = "Hi, " ~ name ~ "!"
pushString(t, "Hi ");
pushGlobal(t, "name");
pushString(t, "!");
cat(t, 3);
setGlobal(t, "x");
-----

Params:
	num = How many values to concatenate.

Returns:
	The stack index of the resulting object.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">cat</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">num</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">num</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"cat - Cannot concatenate 0 things"</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="i">num</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">slot</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Identifier"><span class="i">num</span></span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">num</span></span> &gt; <span class="e Int"><span class="n">1</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">catImpl</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>], <span class="i">slot</span>, <span class="i">num</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="i">num</span> - <span class="n">1</span>)</span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">slot</span></span>;</span>
}</span></span></span>

<span class="bc">/**
Performs concatenation-assignment.  dest is the stack slot of the destination object (the object to
append to).  num is how many values there are on the right-hand side and is expected to be at least 1.
The RHS values are on the top of the stack.  Pops the RHS values off the stack.

-----
// x ~= "Hi, " ~ name ~ "!"
auto dest = pushGlobal(t, "x");
pushString(t, "Hi ");
pushGlobal(t, "name");
pushString(t, "!");
cateq(t, dest, 3); // 3 rhs values
setGlobal(t, "x"); // have to put the new value back (since it's a string)
-----

Params:
	num = How many values are on the RHS to be appended.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">cateq</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">num</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">num</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"cateq - Cannot append 0 things"</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="i">num</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">catEqImpl</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">fakeToAbs</span>(<span class="i">t</span>, <span class="i">dest</span>)], <span class="i">t</span>.<span class="i">stackIndex</span> - <span class="i">num</span>, <span class="i">num</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="i">num</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Returns whether or not obj is an 'instance' and derives from base.  Throws an error if base is not a class.
Works just like the as operator in MiniD.

Params:
	obj = The stack index of the value to test.
	base = The stack index of the _base class.  Must be a 'class'.

Returns:
	true if obj is an 'instance' and it derives from base.  False otherwise.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">as</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">obj</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">base</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">asImpl</span></span>(<span class="i">t</span>, <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">obj</span>), <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">base</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Increments the value at the given _slot.  Calls opInc metamethods.

Params:
	slot = The stack index of the value to increment.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">inc</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">incImpl</span></span>(<span class="i">t</span>, <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">slot</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Decrements the value at the given _slot.  Calls opDec metamethods.

Params:
	slot = The stack index of the value to decrement.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">dec</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">decImpl</span></span>(<span class="i">t</span>, <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">slot</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Gets the class of instances, base class of classes, or the parent namespace of namespaces and
pushes it onto the stack. Throws an error if the value at the given _slot is not a class, instance,
or namespace.  Works just like "x.super" in MiniD.  For classes and namespaces, pushes null if
there is no base or parent.

Params:
	slot = The stack index of the instance, class, or namespace whose class, base, or parent to get.

Returns:
	The stack index of the newly-pushed value.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">superOf</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">superOfImpl</span>(<span class="i">t</span>, <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">slot</span>)))</span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Function calling</span>

<span class="bc">/**
Calls the object at the given _slot.  The parameters (including 'this') are assumed to be all the
values after that _slot to the top of the stack.

The 'this' parameter is, according to the language specification, null if no explicit context is given.
You must still push this null value, however.

An example of calling a function:

-----
// Let's translate `x = f(5, "hi")` into API calls.

// 1. Push the function (or any callable object -- like instances, threads).
auto slot = pushGlobal(t, "f");

// 2. Push the 'this' parameter.  This is 'null' if you don'_t care.  Notice in the MiniD code, we didn'_t
// put a 'with', so 'null' will be used as the context.
pushNull(t);

// 3. Push any params.
pushInt(t, 5);
pushString(t, "hi");

// 4. Call it.
rawCall(t, slot, 1);

// 5. Do something with the return values.  setGlobal pops the return value off the stack, so now the
// stack is back the way it was when we started.
setGlobal(t, "x");
-----

Params:
	slot = The _slot containing the object to call.
	numReturns = How many return values you want.  Can be -1, which means you'll get all returns.

Returns:
	The number of return values given by the function.  If numReturns was -1, this is exactly how
	many returns the function gave.  If numReturns was &gt;= 0, this is the same as numReturns (and
	not exactly useful since you already know it).
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">rawCall</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numReturns</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">absSlot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">numParams</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Paren">(<span class="e Plus"><span class="e Identifier"><span class="i">absSlot</span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numParams</span></span> &lt; <span class="e Int"><span class="n">1</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"rawCall - too few parameters (must have at least 1 for the context)"</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numReturns</span></span> &lt; <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"rawCall - invalid number of returns (must be &gt;= -1)"</span>)</span>;</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">absSlot</span>, <span class="i">numReturns</span>, <span class="i">callPrologue</span>(<span class="i">t</span>, <span class="i">absSlot</span>, <span class="i">numReturns</span>, <span class="i">numParams</span>, <span class="k">null</span>))</span>;</span>
}</span></span></span>

<span class="bc">/**
Calls a method of an object at the given _slot.  The parameters (including a spot for 'this') are assumed
to be all the values after that _slot to the top of the stack.

This function behaves identically to a method call within the language, including calling opMethod
metamethods if the method is not found.

The process of calling a method is very similar to calling a normal function.

-----
// Let's translate `o.f(3)` into API calls.

// 1. Push the object on which the method will be called.
auto slot = pushGlobal(t, "o");

// 2. Make room for 'this'.  If you want to call the method with a custom 'this', push it here.
// Otherwise, we'll let MiniD figure out the 'this' and we can just push null.
pushNull(t);

// 3. Push any params.
pushInt(t, 3);

// 4. Call it with the method name.  We didn'_t push a custom 'this', so we don'_t pass '_true' for that param.
methodCall(t, slot, "f", 0);

// We didn'_t ask for any return values, so the stack is how it was before we began.
-----

Params:
	slot = The _slot containing the object on which the method will be called.
	name = The _name of the method to call.
	numReturns = How many return values you want.  Can be -1, which means you'll get all returns.
	customThis = If true, the 'this' parameter you push after the object will be respected and
		passed as 'this' to the method (though the method will still be looked up in the object).
		The default is false, where the context will be determined automatically (i.e. it's
		the object on which the method is being called).

Returns:
	The number of return values given by the function.  If numReturns was -1, this is exactly how
	many returns the function gave.  If numReturns was &gt;= 0, this is the same as numReturns (and
	not exactly useful since you already know it).
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">methodCall</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numReturns</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">customThis</span> = <span class="e Bool"><span class="k">false</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">absSlot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">numParams</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Paren">(<span class="e Plus"><span class="e Identifier"><span class="i">absSlot</span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numParams</span></span> &lt; <span class="e Int"><span class="n">1</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"methodCall - too few parameters (must have at least 1 for the context)"</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numReturns</span></span> &lt; <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"methodCall - invalid number of returns (must be &gt;= -1)"</span>)</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">self</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">absSlot</span></span>]</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">methodName</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">string</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">name</span>)</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tmp</span> = <span class="e Call"><span class="e Identifier"><span class="i">commonMethodCall</span></span>(<span class="i">t</span>, <span class="i">absSlot</span>, <span class="i">self</span>, <span class="i">self</span>, <span class="i">methodName</span>, <span class="i">numReturns</span>, <span class="i">numParams</span>, <span class="i">customThis</span>)</span>;</span></span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">absSlot</span>, <span class="i">numReturns</span>, <span class="i">tmp</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Same as above, but expects the name of the method to be on top of the stack (after the parameters).

The parameters and return value are the same as above.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">methodCall</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numReturns</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">customThis</span> = <span class="e Bool"><span class="k">false</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">absSlot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isString</span></span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"methodCall - Method name must be a string, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">methodName</span> = <span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span>.<span class="e Identifier"><span class="i">mString</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">numParams</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Paren">(<span class="e Plus"><span class="e Identifier"><span class="i">absSlot</span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numParams</span></span> &lt; <span class="e Int"><span class="n">1</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"methodCall - too few parameters (must have at least 1 for the context)"</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numReturns</span></span> &lt; <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"methodCall - invalid number of returns (must be &gt;= -1)"</span>)</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">self</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">absSlot</span></span>]</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tmp</span> = <span class="e Call"><span class="e Identifier"><span class="i">commonMethodCall</span></span>(<span class="i">t</span>, <span class="i">absSlot</span>, <span class="i">self</span>, <span class="i">self</span>, <span class="i">methodName</span>, <span class="i">numReturns</span>, <span class="i">numParams</span>, <span class="i">customThis</span>)</span>;</span></span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">absSlot</span>, <span class="i">numReturns</span>, <span class="i">tmp</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Performs a super call.  This function will only work if the currently-executing function was called as
a method of a value of type 'instance'.

This function works similarly to other kinds of calls, but it's somewhat odd.  Other calls have you push the
thing to call followed by 'this' or a spot for it.  This call requires you to just give it two empty slots.
It will fill them in (and what it puts in them is really kind of scary).  Regardless, when the super method is
called (if there is one), its 'this' parameter will be the currently-executing function's 'this' parameter.

The process of performing a supercall is not really that much different from other kinds of calls.

-----
// Let's translate `super.f(3)` into API calls.

// 1. Push a null.
auto slot = pushNull(t);

// 2. Push another null.  You can'_t call a super method with a custom 'this'.
pushNull(t);

// 3. Push any params.
pushInt(t, 3);

// 4. Call it with the method name.
superCall(t, slot, "f", 0);

// We didn'_t ask for any return values, so the stack is how it was before we began.
-----

Params:
	slot = The first empty _slot.  There should be another one on top of it.  Then come any parameters.
	name = The _name of the method to call.
	numReturns = How many return values you want.  Can be -1, which means you'll get all returns.

Returns:
	The number of return values given by the function.  If numReturns was -1, this is exactly how
	many returns the function gave.  If numReturns was &gt;= 0, this is the same as numReturns (and
	not exactly useful since you already know it).
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">superCall</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numReturns</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="lc">// Invalid call?</span>
	<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> == <span class="e Int"><span class="n">0</span></span></span> || <span class="e Identity"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">proto</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"superCall - Attempting to perform a supercall in a function where there is no super class"</span>)</span>;</span></span>

	<span class="lc">// Get num params</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">absSlot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">numParams</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Paren">(<span class="e Plus"><span class="e Identifier"><span class="i">absSlot</span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numParams</span></span> &lt; <span class="e Int"><span class="n">1</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"superCall - too few parameters (must have at least 1 for the context)"</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numReturns</span></span> &lt; <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"superCall - invalid number of returns (must be &gt;= -1)"</span>)</span>;</span></span>

	<span class="lc">// Get this</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">_this</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">_this</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">_this</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="n">0</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"superCall - Attempting to perform a supercall in a function where 'this' is a '{}', not an 'instance' or 'class'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="lc">// Do the call</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">methodName</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">string</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">name</span>)</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">commonMethodCall</span></span>(<span class="i">t</span>, <span class="i">absSlot</span>, <span class="i">_this</span>, &amp;<span class="i">MDValue</span>(<span class="i">t</span>.<span class="i">currentAR</span>.<span class="i">proto</span>), <span class="i">methodName</span>, <span class="i">numReturns</span>, <span class="i">numParams</span>, <span class="k">false</span>)</span>;</span></span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">absSlot</span>, <span class="i">numReturns</span>, <span class="i">ret</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Same as above, but expects the method name to be at the top of the stack (after the parameters).

The parameters and return value are the same as above.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">superCall</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numReturns</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="lc">// Get the method name</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">absSlot</span> = <span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isString</span></span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"superCall - Method name must be a string, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">methodName</span> = <span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span>.<span class="e Identifier"><span class="i">mString</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>

	<span class="lc">// Invalid call?</span>
	<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> == <span class="e Int"><span class="n">0</span></span></span> || <span class="e Identity"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">proto</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"superCall - Attempting to perform a supercall in a function where there is no super class"</span>)</span>;</span></span>

	<span class="lc">// Get num params</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">numParams</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Paren">(<span class="e Plus"><span class="e Identifier"><span class="i">absSlot</span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numParams</span></span> &lt; <span class="e Int"><span class="n">1</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"superCall - too few parameters (must have at least 1 for the context)"</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numReturns</span></span> &lt; <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"superCall - invalid number of returns (must be &gt;= -1)"</span>)</span>;</span></span>

	<span class="lc">// Get this</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">_this</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">_this</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">_this</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="n">0</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"superCall - Attempting to perform a supercall in a function where 'this' is a '{}', not an 'instance' or 'class'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="lc">// Do the call</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">commonMethodCall</span></span>(<span class="i">t</span>, <span class="i">absSlot</span>, <span class="i">_this</span>, &amp;<span class="i">MDValue</span>(<span class="i">t</span>.<span class="i">currentAR</span>.<span class="i">proto</span>), <span class="i">methodName</span>, <span class="i">numReturns</span>, <span class="i">numParams</span>, <span class="k">false</span>)</span>;</span></span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">absSlot</span>, <span class="i">numReturns</span>, <span class="i">ret</span>)</span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Reflective functions</span>

<span class="bc">/**
Gets the fields namespace of the class or instance at the given slot.  Throws an exception if
the value at the given slot is not a class or instance.

Params:
	obj = The stack index of the value whose fields are to be retrieved.

Returns:
	The stack index of the newly-pushed fields namespace.
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">fieldsOf</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">obj</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNamespace</span></span>(<span class="i">t</span>, <span class="i">classobj</span>.<span class="i">fieldsOf</span>(<span class="i">c</span>))</span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i</span> = <span class="e Call"><span class="e Identifier"><span class="i">getInstance</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNamespace</span></span>(<span class="i">t</span>, <span class="i">instance</span>.<span class="i">fieldsOf</span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">i</span>))</span>;</span></span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"fieldsOf - Expected 'class' or 'instance', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
Sees if the object at the stack index `obj` has a field with the given name.  Does not take opField
metamethods into account.  Because of that, only works for tables, classes, instances, and namespaces.
If the object at the stack index `obj` is not one of those types, always returns false.  If this
function returns true, you are guaranteed that accessing a field of the given name on the given object
will succeed.

Params:
	obj = The stack index of the object to test.
	fieldName = The name of the field to look up.

Returns:
	true if the field exists in `obj`; false otherwise.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">hasField</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">obj</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">fieldName</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">name</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">string</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">fieldName</span>)</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Identifier"><span class="i">getValue</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span>;</span></span>

	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Identity"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">table</span></span>.<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">v</span>.<span class="i">mTable</span>, <span class="i">MDValue</span>(<span class="i">name</span>))</span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Identity"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">classobj</span></span>.<span class="e Identifier"><span class="i">getField</span></span></span>(<span class="i">v</span>.<span class="i">mClass</span>, <span class="i">name</span>)</span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Identity"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">instance</span></span>.<span class="e Identifier"><span class="i">getField</span></span></span>(<span class="i">v</span>.<span class="i">mInstance</span>, <span class="i">name</span>)</span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Identity"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">v</span>.<span class="i">mNamespace</span>, <span class="i">name</span>)</span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="bc">/**
Sees if a method can be called on the object at stack index `obj`.  Does not take opMethod metamethods
into account, but does take type metatables into account.  In other words, if you look up a method in
an object and this function returns true, you are guaranteed that calling a method of that name on
that object will succeed.

Params:
	obj = The stack index of the obejct to test.
	methodName = The name of the method to look up.

Returns:
	true if the method can be called on `obj`; false otherwise.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">hasMethod</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">obj</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">methodName</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">dummy</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
	<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">lookupMethod</span></span>(<span class="i">t</span>, <span class="i">getValue</span>(<span class="i">t</span>, <span class="i">obj</span>), <span class="i">string</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">methodName</span>), <span class="i">dummy</span>)</span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
Gets the attributes table of the given object and pushes it onto the stack.  Pushes null if the given
object has no attributes.  Throws an error if the object is not a function, class, or namespace.

Params:
	obj = The stack index of the object whose attributes table is to be retrieved.

Returns:
	The stack index of the newly-pushed value (either the attributes table, or null if it has none).
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">getAttributes</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">obj</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDTable</span></span><span class="t Pointer">*</span> <span class="i">attrs</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">attrs</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">f</span></span>.<span class="e Identifier"><span class="i">attrs</span></span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">attrs</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">c</span></span>.<span class="e Identifier"><span class="i">attrs</span></span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">attrs</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">n</span></span>.<span class="e Identifier"><span class="i">attrs</span></span></span></span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"getAttributes - Can only get attributes of functions, classes, and namespaces, not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span></span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">attrs</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushTable</span></span>(<span class="i">t</span>, <span class="i">attrs</span>)</span>;</span></span>
}</span></span></span>

<span class="bc">/**
Pops the table off the top of the stack and sets it as the attributes table of the given object.  The
value at the top of the stack can also be null, in which case it will remove the attributes table
from the given object.  Throws an error if the given object is not a function, class, or namespace,
or if the value at the top of the stack is neither a table nor null.

Params:
	obj = The stack index of the object whose attributes table is to be set.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">setAttributes</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">obj</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">attrs</span> = <span class="e Call"><span class="e Identifier"><span class="i">getTable</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Identity"><span class="e Identifier"><span class="i">attrs</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span> &amp;&amp; <span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isNull</span></span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setAttributes - 'table' or 'null' expected for attributes, not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">f</span></span>.<span class="e Identifier"><span class="i">attrs</span></span></span> = <span class="e Identifier"><span class="i">attrs</span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">c</span></span>.<span class="e Identifier"><span class="i">attrs</span></span></span> = <span class="e Identifier"><span class="i">attrs</span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">n</span></span>.<span class="e Identifier"><span class="i">attrs</span></span></span> = <span class="e Identifier"><span class="i">attrs</span></span></span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setAttributes - Can only set attributes of functions, classes, and namespaces, not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span></span></span>
}</span></span></span>

<span class="bc">/**
Sees whether or not the given object has attributes.  Always returns false if the given object is
not a function, class, or namespace.

Params:
	obj = The stack index of the object to test.

Returns:
	True if the object has an attributes table; false otherwise.
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">hasAttributes</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">obj</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">f</span></span>.<span class="e Identifier"><span class="i">attrs</span></span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">getClass</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">c</span></span>.<span class="e Identifier"><span class="i">attrs</span></span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, <span class="i">obj</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">n</span></span>.<span class="e Identifier"><span class="i">attrs</span></span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span></span></span></span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Debugging functions</span>

<span class="bc">/**
TODO: doc me
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">setHookFunc</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">ubyte</span></span> <span class="i">mask</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">uint</span></span> <span class="i">hookDelay</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkNumParams</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Call"><span class="e Identifier"><span class="i">getFunction</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Identity"><span class="e Identifier"><span class="i">f</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span> &amp;&amp; <span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isNull</span></span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"setHookFunc - hook func must be 'function' or 'null', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">mask</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookDelay</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookCounter</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookFunc</span></span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookDelay</span></span></span> = <span class="e Identifier"><span class="i">hookDelay</span></span></span>;</span>
		
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">hookDelay</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
			<span class="s Expression"><span class="e AndAssign"><span class="e Identifier"><span class="i">mask</span></span> &amp;= <span class="e Dot"><span class="e Dot"><span class="e Comp">~<span class="e Identifier"><span class="i">MDThread</span></span></span>.<span class="e Identifier"><span class="i">Hook</span></span></span>.<span class="e Identifier"><span class="i">Delay</span></span></span></span>;</span>
		<span class="k">else</span>
			<span class="s Expression"><span class="e OrAssign"><span class="e Identifier"><span class="i">mask</span></span> |= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">Hook</span></span></span>.<span class="e Identifier"><span class="i">Delay</span></span></span></span>;</span></span>

		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookCounter</span></span></span> = <span class="e Identifier"><span class="i">hookDelay</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookFunc</span></span></span> = <span class="e Identifier"><span class="i">f</span></span></span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hooks</span></span></span> = <span class="e Identifier"><span class="i">mask</span></span></span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
TODO: doc me
*/</span>
<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">getHookFunc</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookFunc</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">hookFunc</span>)</span>;</span></span>
}</span></span></span>

<span class="bc">/**
TODO: doc me
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">ubyte</span></span> <span class="i">getHookMask</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hooks</span></span></span>;</span>
}</span></span></span>

<span class="bc">/**
TODO: doc me
*/</span>
<span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">getHookDelay</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookDelay</span></span></span>;</span>
}</span></span></span>

<span class="d Debug"><span class="k">debug</span>
<span class="d Compound">{
	<span class="d Import"><span class="k">import</span> <span class="i">tango</span>.<span class="i">io</span>.<span class="i">Stdout</span>;</span>

	<span class="bc">/**
	$(B Debug mode only.)  Print out the contents of the stack to Stdout in the following format:

-----
[xxx:yyyy]: val: type
-----

	Where $(I xxx) is the absolute stack index; $(I yyyy) is the stack index relative to the currently-executing function's
	stack frame (negative numbers for lower slots, 0 is the first slot of the stack frame); $(I val) is a raw string
	representation of the value in that slot; and $(I type) is the type of that value.
	*/</span>
	<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">printStack</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
	<span class="s FuncBody"><span class="s Compound">{
		<span class="s Expression"><span class="e Dot"><span class="e Identifier"><span class="i">Stdout</span></span>.<span class="e Identifier"><span class="i">newline</span></span></span>;</span>
		<span class="s Expression"><span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">Stdout</span></span>(<span class="sl">"-----Stack Dump-----"</span>)</span>.<span class="e Identifier"><span class="i">newline</span></span></span>;</span>

		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tmp</span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span>;</span></span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">top</span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span>;</span></span>

		<span class="s For"><span class="k">for</span>(<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">i</span> = <span class="e Int"><span class="n">0</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">i</span></span> &lt; <span class="e Identifier"><span class="i">top</span></span></span>; <span class="e PostIncr"><span class="e Identifier"><span class="i">i</span></span>++</span>)
		<span class="s Compound">{
			<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Rel"><span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">i</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> &gt;= <span class="e Int"><span class="n">0</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">i</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> &lt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">max</span></span></span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushToString</span></span>(<span class="i">t</span>, <span class="i">i</span>, <span class="k">true</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">i</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">Stdout</span></span>.<span class="e Identifier"><span class="i">formatln</span></span></span>(<span class="sl">"[{,3}:{,4}]: {}: {}"</span>, <span class="i">i</span>, <span class="k">cast</span>(<span class="i">word</span>)<span class="i">i</span> - <span class="k">cast</span>(<span class="i">word</span>)<span class="i">tmp</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="n">2</span>)</span>;</span>
			}</span>
			<span class="k">else</span>
				<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">Stdout</span></span>.<span class="e Identifier"><span class="i">formatln</span></span></span>(<span class="sl">"[{,3}:{,4}]: {:x16}: {:x}"</span>, <span class="i">i</span>, <span class="k">cast</span>(<span class="i">word</span>)<span class="i">i</span> - <span class="k">cast</span>(<span class="i">word</span>)<span class="i">tmp</span>, *<span class="k">cast</span>(<span class="k">ulong</span>*)&amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">i</span>].<span class="i">mInt</span>, <span class="i">t</span>.<span class="i">stack</span>[<span class="i">i</span>].<span class="i">type</span>)</span>;</span></span>
		}</span></span>

		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span> = <span class="e Identifier"><span class="i">tmp</span></span></span>;</span>

		<span class="s Expression"><span class="e Dot"><span class="e Identifier"><span class="i">Stdout</span></span>.<span class="e Identifier"><span class="i">newline</span></span></span>;</span>
	}</span></span></span>

	<span class="bc">/**
	$(B Debug mode only.)  Print out the call stack in reverse, starting from the currently-executing function and
	going back, in the following format (without quotes; I have to put them to keep DDoc happy):

-----
"Record: name"
	"Base: base"
	"Saved Top: top"
	"Vararg Base: vargBase"
	"Returns Slot: retSlot"
	"Num Returns: numRets"
-----

	Where $(I name) is the name of the function at that level; $(I base) is the absolute stack index of where this activation
	record's stack frame begins; $(I top) is the absolute stack index of the end of its stack frame; $(I vargBase) is the
	absolute stack index of where its variadic args (if any) begin; $(I retSlot) is the absolute stack index where return
	values (if any) will started to be copied upon that function returning; and $(I numRets) being the number of returns that
	the calling function expects it to return (-1 meaning "as many as possible").

	This only prints out the current thread's call stack.  It does not take coroutine resumes and yields into account (since
	that's pretty much impossible).
	*/</span>
	<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">printCallStack</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
	<span class="s FuncBody"><span class="s Compound">{
		<span class="s Expression"><span class="e Dot"><span class="e Identifier"><span class="i">Stdout</span></span>.<span class="e Identifier"><span class="i">newline</span></span></span>;</span>
		<span class="s Expression"><span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">Stdout</span></span>(<span class="sl">"-----Call Stack-----"</span>)</span>.<span class="e Identifier"><span class="i">newline</span></span></span>;</span>

		<span class="s For"><span class="k">for</span>(<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">i</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">i</span></span> &gt;= <span class="e Int"><span class="n">0</span></span></span>; <span class="e PostDecr"><span class="e Identifier"><span class="i">i</span></span>--</span>)
		<span class="s Compound">{
			<span class="s With"><span class="k">with</span>(<span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">actRecs</span></span></span>[<span class="e Identifier"><span class="i">i</span></span>]</span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">Stdout</span></span>.<span class="e Identifier"><span class="i">formatln</span></span></span>(<span class="sl">"Record {}"</span>, <span class="i">func</span>.<span class="i">name</span>.<span class="i">toString</span>())</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">Stdout</span></span>.<span class="e Identifier"><span class="i">formatln</span></span></span>(<span class="sl">"\tBase: {}"</span>, <span class="i">base</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">Stdout</span></span>.<span class="e Identifier"><span class="i">formatln</span></span></span>(<span class="sl">"\tSaved Top: {}"</span>, <span class="i">savedTop</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">Stdout</span></span>.<span class="e Identifier"><span class="i">formatln</span></span></span>(<span class="sl">"\tVararg Base: {}"</span>, <span class="i">vargBase</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">Stdout</span></span>.<span class="e Identifier"><span class="i">formatln</span></span></span>(<span class="sl">"\tReturns Slot: {}"</span>, <span class="i">returnSlot</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">Stdout</span></span>.<span class="e Identifier"><span class="i">formatln</span></span></span>(<span class="sl">"\tNum Returns: {}"</span>, <span class="i">numReturns</span>)</span>;</span>
			}</span></span>
		}</span></span>

		<span class="s Expression"><span class="e Dot"><span class="e Identifier"><span class="i">Stdout</span></span>.<span class="e Identifier"><span class="i">newline</span></span></span>;</span>
	}</span></span></span>
}</span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Package</span>
<span class="lc">// ================================================================================================================================================</span>

<span class="d Protection"><span class="k">package</span>:

<span class="lc">// Free all objects.</span>
<span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">freeAll</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s For"><span class="k">for</span>(<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">pcur</span> = <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">gcHead</span></span></span>;</span></span> <span class="e Identity"><span class="e Deref">*<span class="e Identifier"><span class="i">pcur</span></span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>; )
	<span class="s Compound">{
		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">cur</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">pcur</span></span></span>;</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Paren">(<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">MDBaseObject</span></span><span class="t Pointer">*</span>)<span class="e Identifier"><span class="i">cur</span></span></span>)</span>.<span class="e Identifier"><span class="i">mType</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span>)
		<span class="s Compound">{
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">MDInstance</span></span><span class="t Pointer">*</span>)<span class="e Identifier"><span class="i">cur</span></span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">finalizer</span></span></span> &amp;&amp; <span class="e Paren">(<span class="e Equal"><span class="e Paren">(<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">cur</span></span>.<span class="e Identifier"><span class="i">flags</span></span></span> &amp; <span class="e Dot"><span class="e Identifier"><span class="i">GCBits</span></span>.<span class="e Identifier"><span class="i">Finalized</span></span></span></span>)</span> == <span class="e Int"><span class="n">0</span></span></span>)</span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">pcur</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">cur</span></span>.<span class="e Identifier"><span class="i">next</span></span></span></span>;</span>

				<span class="s Expression"><span class="e OrAssign"><span class="e Dot"><span class="e Identifier"><span class="i">cur</span></span>.<span class="e Identifier"><span class="i">flags</span></span></span> |= <span class="e Dot"><span class="e Identifier"><span class="i">GCBits</span></span>.<span class="e Identifier"><span class="i">Finalized</span></span></span></span>;</span>
				<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">cur</span></span>.<span class="e Identifier"><span class="i">next</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">finalizable</span></span></span></span>;</span>
				<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">finalizable</span></span></span> = <span class="e Identifier"><span class="i">cur</span></span></span>;</span>
			}</span>
			<span class="k">else</span>
				<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">pcur</span></span> = <span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">cur</span></span></span>.<span class="e Identifier"><span class="i">next</span></span></span></span>;</span></span>
		}</span>
		<span class="k">else</span>
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">pcur</span></span> = <span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">cur</span></span></span>.<span class="e Identifier"><span class="i">next</span></span></span></span>;</span></span>
	}</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">runFinalizers</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Identity"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">finalizable</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)</span>;</span>

	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">GCObject</span></span><span class="t Pointer">*</span> <span class="i">next</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

	<span class="s For"><span class="k">for</span>(<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">cur</span> = <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">gcHead</span></span></span>;</span></span> <span class="e Identity"><span class="e Identifier"><span class="i">cur</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>; <span class="e Assign"><span class="e Identifier"><span class="i">cur</span></span> = <span class="e Identifier"><span class="i">next</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">next</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">cur</span></span>.<span class="e Identifier"><span class="i">next</span></span></span></span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">free</span></span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">cur</span>)</span>;</span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushStringObj</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">o</span>))</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushTable</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDTable</span></span><span class="t Pointer">*</span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">o</span>))</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushArray</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDArray</span></span><span class="t Pointer">*</span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">o</span>))</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushFunction</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDFunction</span></span><span class="t Pointer">*</span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">o</span>))</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushClass</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">o</span>))</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushInstance</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDInstance</span></span><span class="t Pointer">*</span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">o</span>))</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushNamespace</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDNamespace</span></span><span class="t Pointer">*</span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">o</span>))</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushWeakRefObj</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDWeakRef</span></span><span class="t Pointer">*</span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>(<span class="i">o</span>))</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushFuncDef</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDFuncDef</span></span><span class="t Pointer">*</span> <span class="i">o</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">v</span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">FuncDef</span></span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mBaseObj</span></span></span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">MDBaseObject</span></span><span class="t Pointer">*</span>)<span class="e Identifier"><span class="i">o</span></span></span></span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">v</span>)</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">getStringObj</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mString</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDTable</span></span><span class="t Pointer">*</span> <span class="i">getTable</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mTable</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDArray</span></span><span class="t Pointer">*</span> <span class="i">getArray</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mArray</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDFunction</span></span><span class="t Pointer">*</span> <span class="i">getFunction</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mFunction</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">getClass</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mClass</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDInstance</span></span><span class="t Pointer">*</span> <span class="i">getInstance</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mInstance</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDNamespace</span></span><span class="t Pointer">*</span> <span class="i">getNamespace</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mNamespace</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDNativeObj</span></span><span class="t Pointer">*</span> <span class="i">getNative</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">NativeObj</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mNativeObj</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDWeakRef</span></span><span class="t Pointer">*</span> <span class="i">getWeakRef</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">WeakRef</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mWeakRef</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDFuncDef</span></span><span class="t Pointer">*</span> <span class="i">getFuncDef</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>]</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">FuncDef</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">MDFuncDef</span></span><span class="t Pointer">*</span>)<span class="e Identifier"><span class="i">v</span></span></span>.<span class="e Identifier"><span class="i">mBaseObj</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">push</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="k">ref</span> <span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">val</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Not">!<span class="e Paren">(<span class="e AndAnd"><span class="e Paren">(<span class="e Rel"><span class="e Address">&amp;<span class="e Identifier"><span class="i">val</span></span></span> &gt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>.<span class="e Identifier"><span class="i">ptr</span></span></span></span>)</span> &amp;&amp; <span class="e Paren">(<span class="e Rel"><span class="e Address">&amp;<span class="e Identifier"><span class="i">val</span></span></span> &lt; <span class="e Plus"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>.<span class="e Identifier"><span class="i">ptr</span></span></span> + <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span></span>)</span></span>)</span></span>, <span class="e String"><span class="sl">"trying to push a value that's on the stack"</span></span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkStack</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">stackIndex</span>)</span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span>]</span> = <span class="e Identifier"><span class="i">val</span></span></span>;</span>
	<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span>++</span>;</span>

	<span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">word</span></span>)<span class="e Paren">(<span class="e Minus"><span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span></span>)</span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">getValue</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">slot</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Call"><span class="e Identifier"><span class="i">fakeToAbs</span></span>(<span class="i">t</span>, <span class="i">slot</span>)</span>]</span>;</span>
}</span></span></span>

<span class="lc">// don't call this if t.calldepth == 0 or with depth &gt;= t.calldepth</span>
<span class="lc">// returns null if the given index is a tailcall</span>
<span class="d Function"><span class="t Identifier"><span class="i">ActRecord</span></span><span class="t Pointer">*</span> <span class="i">getActRec</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">depth</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">depth</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>;</span></span>

	<span class="s For"><span class="k">for</span>(<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">word</span></span> <span class="i">idx</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &gt;= <span class="e Int"><span class="n">0</span></span></span>; <span class="e PostDecr"><span class="e Identifier"><span class="i">idx</span></span>--</span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">depth</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">actRecs</span></span></span>[<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">idx</span></span></span>]</span>;</span>
		<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">depth</span></span> &lt;= <span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">actRecs</span></span></span>[<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">idx</span></span></span>]</span>.<span class="e Identifier"><span class="i">numTailcalls</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span></span>

		<span class="s Expression"><span class="e MinusAssign"><span class="e Identifier"><span class="i">depth</span></span> -= <span class="e Paren">(<span class="e Plus"><span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">actRecs</span></span></span>[<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">idx</span></span></span>]</span>.<span class="e Identifier"><span class="i">numTailcalls</span></span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">int</span></span> <span class="i">pcToLine</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">ActRecord</span></span><span class="t Pointer">*</span> <span class="i">ar</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">Instruction</span></span><span class="t Pointer">*</span> <span class="i">pc</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">line</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">def</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">scriptFunc</span></span></span>;</span></span>
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">instructionIndex</span> = <span class="e Minus"><span class="e Minus"><span class="e Identifier"><span class="i">pc</span></span> - <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">def</span></span>.<span class="e Identifier"><span class="i">code</span></span></span>.<span class="e Identifier"><span class="i">ptr</span></span></span></span> - <span class="e Int"><span class="n">1</span></span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">instructionIndex</span></span> &lt; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">def</span></span>.<span class="e Identifier"><span class="i">lineInfo</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">line</span></span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">def</span></span>.<span class="e Identifier"><span class="i">lineInfo</span></span></span>[<span class="e Identifier"><span class="i">instructionIndex</span></span>]</span></span>;</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">line</span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">int</span></span> <span class="i">getDebugLine</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">depth</span> = <span class="e Int"><span class="n">0</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">0</span></span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ar</span> = <span class="e Call"><span class="e Identifier"><span class="i">getActRec</span></span>(<span class="i">t</span>, <span class="i">depth</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e OrOr"><span class="e Identity"><span class="e Identifier"><span class="i">ar</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span> || <span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">func</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span></span> || <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">0</span></span>;</span></span>
		
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pcToLine</span></span>(<span class="i">ar</span>, <span class="i">ar</span>.<span class="i">pc</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">def</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">scriptFunc</span></span></span>;</span></span>

	<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">line</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">instructionIndex</span> = <span class="e Minus"><span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> - <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">def</span></span>.<span class="e Identifier"><span class="i">code</span></span></span>.<span class="e Identifier"><span class="i">ptr</span></span></span></span> - <span class="e Int"><span class="n">1</span></span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">instructionIndex</span></span> &lt; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">def</span></span>.<span class="e Identifier"><span class="i">lineInfo</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">line</span></span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">def</span></span>.<span class="e Identifier"><span class="i">lineInfo</span></span></span>[<span class="e Identifier"><span class="i">instructionIndex</span></span>]</span></span>;</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">line</span></span>;</span>
}</span></span></span>

<span class="lc">// ================================================================================================================================================</span>
<span class="lc">// Private</span>
<span class="lc">// ================================================================================================================================================</span>

<span class="d Protection"><span class="k">private</span>:

<span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">runFinalizers</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">finalizable</span></span></span>)
	<span class="s Compound">{
		<span class="s For"><span class="k">for</span>(<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">pcur</span> = <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">finalizable</span></span></span>;</span></span> <span class="e Identity"><span class="e Deref">*<span class="e Identifier"><span class="i">pcur</span></span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>; )
		<span class="s Compound">{
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">cur</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">pcur</span></span></span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">MDInstance</span></span><span class="t Pointer">*</span>)<span class="e Identifier"><span class="i">cur</span></span></span>;</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">pcur</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">cur</span></span>.<span class="e Identifier"><span class="i">next</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">cur</span></span>.<span class="e Identifier"><span class="i">next</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">gcHead</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">gcHead</span></span></span> = <span class="e Identifier"><span class="i">cur</span></span></span>;</span>

			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">cur</span></span>.<span class="e Identifier"><span class="i">flags</span></span></span> = <span class="e Or"><span class="e Paren">(<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">cur</span></span>.<span class="e Identifier"><span class="i">flags</span></span></span> &amp; <span class="e Dot"><span class="e Comp">~<span class="e Identifier"><span class="i">GCBits</span></span></span>.<span class="e Identifier"><span class="i">Marked</span></span></span></span>)</span> | <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Not">!<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">markVal</span></span></span></span></span>;</span>

			<span class="lc">// sanity check</span>
			<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">finalizer</span></span></span>)
			<span class="s Compound">{
				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oldLimit</span> = <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">gcLimit</span></span></span>;</span></span>
				<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">gcLimit</span></span></span> = <span class="e Dot"><span class="e Typeof"><span class="t Typeof"><span class="k">typeof</span>(<span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">gcLimit</span></span></span>)</span></span>.<span class="e Identifier"><span class="i">max</span></span></span></span>;</span>

				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">i</span>.<span class="i">finalizer</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushInstance</span></span>(<span class="i">t</span>, <span class="i">i</span>)</span>;</span>
				
				<span class="s Try"><span class="s Catch"><span class="k">try</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">rawCall</span></span>(<span class="i">t</span>, -<span class="n">2</span>, <span class="n">0</span>)</span>;</span>
				<span class="k">catch</span>(<span class="o Parameter"><span class="t Identifier"><span class="i">MDException</span></span> <span class="i">e</span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">catchException</span></span>(<span class="i">t</span>)</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
				}</span></span></span>

				<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">gcLimit</span></span></span> = <span class="e Identifier"><span class="i">oldLimit</span></span></span>;</span>
			}</span></span>
		}</span></span>
	}</span></span>
}</span></span></span>

<span class="lc">// ============================================================================</span>
<span class="lc">// Stack Manipulation</span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">checkNumParams</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">n</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Debug"><span class="k">debug</span> <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> &gt; <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span></span>, <span class="e Paren">(<span class="e Comma"><span class="e Comma"><span class="e Call"><span class="e Identifier"><span class="i">printStack</span></span>(<span class="i">t</span>)</span>, <span class="e Call"><span class="e Identifier"><span class="i">printCallStack</span></span>(<span class="i">t</span>)</span></span>, <span class="e String"><span class="sl">"fail."</span></span></span>)</span>)</span>;</span></span>

	<span class="lc">// Don'_t count 'this'</span>
	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Paren">(<span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>)</span> &lt; <span class="e Identifier"><span class="i">n</span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Not enough parameters (expected {}, only have {})"</span>, <span class="i">n</span>, <span class="i">stackSize</span>(<span class="i">t</span>) - <span class="n">1</span>)</span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">RelStack</span></span> <span class="i">fakeToRel</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">fake</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> &gt; <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span></span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">size</span> = <span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">fake</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">fake</span></span> += <span class="e Identifier"><span class="i">size</span></span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">fake</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">fake</span></span> &gt;= <span class="e Identifier"><span class="i">size</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Invalid index {} (size = {})"</span>, <span class="i">fake</span>, <span class="i">size</span>)</span>;</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">RelStack</span></span>)<span class="e Identifier"><span class="i">fake</span></span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">fakeToAbs</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">fake</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Return"><span class="k">return</span> <span class="e Plus"><span class="e Call"><span class="e Identifier"><span class="i">fakeToRel</span></span>(<span class="i">t</span>, <span class="i">fake</span>)</span> + <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">checkStack</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">idx</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &gt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>, <span class="i">idx</span> * <span class="n">2</span>)</span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">stackSize</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">size</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oldBase</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>.<span class="e Identifier"><span class="i">ptr</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">resizeArray</span></span></span>(<span class="i">t</span>.<span class="i">stack</span>, <span class="i">size</span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">newBase</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>.<span class="e Identifier"><span class="i">ptr</span></span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">newBase</span></span> !<span class="k">is</span> <span class="e Identifier"><span class="i">oldBase</span></span></span>)
		<span class="s For"><span class="k">for</span>(<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">uv</span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">upvalHead</span></span></span>;</span></span> <span class="e Identity"><span class="e Identifier"><span class="i">uv</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>; <span class="e Assign"><span class="e Identifier"><span class="i">uv</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">uv</span></span>.<span class="e Identifier"><span class="i">nextuv</span></span></span></span>)
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">uv</span></span>.<span class="e Identifier"><span class="i">value</span></span></span> = <span class="e Plus"><span class="e Paren">(<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">uv</span></span>.<span class="e Identifier"><span class="i">value</span></span></span> - <span class="e Identifier"><span class="i">oldBase</span></span></span>)</span> + <span class="e Identifier"><span class="i">newBase</span></span></span></span>;</span></span></span>
}</span></span></span>

<span class="lc">// ============================================================================</span>
<span class="lc">// Function Calling</span>

<span class="d Function"><span class="t Identifier"><span class="i">MDNamespace</span></span><span class="t Pointer">*</span> <span class="i">getEnv</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">depth</span> = <span class="e Int"><span class="n">0</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">globals</span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">depth</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">environment</span></span></span>;</span></span></span>

	<span class="s For"><span class="k">for</span>(<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">word</span></span> <span class="i">idx</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &gt;= <span class="e Int"><span class="n">0</span></span></span>; <span class="e PostDecr"><span class="e Identifier"><span class="i">idx</span></span>--</span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">depth</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">actRecs</span></span></span>[<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">idx</span></span></span>]</span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">environment</span></span></span>;</span>
		<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">depth</span></span> &lt;= <span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">actRecs</span></span></span>[<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">idx</span></span></span>]</span>.<span class="e Identifier"><span class="i">numTailcalls</span></span></span></span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to get environment of function whose activation record was overwritten by a tail call"</span>)</span>;</span></span></span>

		<span class="s Expression"><span class="e MinusAssign"><span class="e Identifier"><span class="i">depth</span></span> -= <span class="e Paren">(<span class="e Plus"><span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">actRecs</span></span></span>[<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">idx</span></span></span>]</span>.<span class="e Identifier"><span class="i">numTailcalls</span></span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">globals</span></span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">commonCall</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">slot</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numReturns</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isScript</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>) <span class="s Compound">{}</span> <span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span>++</span>;</span>
		<span class="s ScopeGuard"><span class="k">scope</span>(<span class="i">exit</span>) <span class="s Expression"><span class="e PostDecr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span>--</span>;</span></span>
	}</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">isScript</span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">execute</span></span>(<span class="i">t</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">numReturns</span></span> == <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Identifier"><span class="i">slot</span></span></span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Identifier"><span class="i">numReturns</span></span></span></span>;</span>
		<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">numReturns</span></span>;</span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">commonMethodCall</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">slot</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">self</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">lookup</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">methodName</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numReturns</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numParams</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">customThis</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">lookupMethod</span></span>(<span class="i">t</span>, <span class="i">lookup</span>, <span class="i">methodName</span>, <span class="i">proto</span>)</span>;</span></span>

	<span class="lc">// Idea is like this:</span>

	<span class="lc">// If we're calling the real method, the object is moved to the 'this' slot and the method takes its place.</span>

	<span class="lc">// If we're calling opMethod, the object is left where it is (or the custom context is moved to its place),</span>
	<span class="lc">// the method name goes where the context was, and we use callPrologue2 with a closure that's not on the stack.</span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">method</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Not">!<span class="e Identifier"><span class="i">customThis</span></span></span>)
			<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">self</span></span></span></span>;</span></span>

		<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span> = <span class="e Identifier"><span class="i">method</span></span></span>;</span>

		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">callPrologue</span></span>(<span class="i">t</span>, <span class="i">slot</span>, <span class="i">numReturns</span>, <span class="i">numParams</span>, <span class="i">proto</span>)</span>;</span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">mm</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">lookup</span>, <span class="i">MM</span>.<span class="i">Method</span>, <span class="i">proto</span>)</span>;</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">mm</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">lookup</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"No implementation of method '{}' or {} for type '{}'"</span>, <span class="i">methodName</span>.<span class="i">toString</span>(), <span class="i">MetaNames</span>[<span class="i">MM</span>.<span class="i">Method</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
		}</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">customThis</span></span>)
			<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
		<span class="k">else</span>
			<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">self</span></span></span></span>;</span></span>

		<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span> = <span class="e Identifier"><span class="i">methodName</span></span></span>;</span>

		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">callPrologue2</span></span>(<span class="i">t</span>, <span class="i">mm</span>, <span class="i">slot</span>, <span class="i">numReturns</span>, <span class="i">slot</span>, <span class="i">numParams</span> + <span class="n">1</span>, <span class="i">proto</span>)</span>;</span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">lookupMethod</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">v</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="k">out</span> <span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMethod</span></span>(<span class="i">v</span>.<span class="i">mClass</span>, <span class="i">name</span>, <span class="i">proto</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>)
				<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span></span>

			<span class="s Goto"><span class="k">goto</span> <span class="k">default</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">getMethod</span></span>(<span class="i">v</span>.<span class="i">mInstance</span>, <span class="i">name</span>, <span class="i">proto</span>)</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMethod</span></span>(<span class="i">v</span>.<span class="i">mTable</span>, <span class="i">name</span>)</span>;</span></span>
			
			<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>)
				<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span></span>

			<span class="s Goto"><span class="k">goto</span> <span class="k">default</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">getMethod</span></span>(<span class="i">v</span>.<span class="i">mNamespace</span>, <span class="i">name</span>)</span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">getMethod</span></span>(<span class="i">t</span>, <span class="i">v</span>.<span class="i">type</span>, <span class="i">name</span>)</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">getMethod</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">cls</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="k">out</span> <span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">classobj</span></span>.<span class="e Identifier"><span class="i">getField</span></span></span>(<span class="i">cls</span>, <span class="i">name</span>, <span class="i">proto</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Deref">*<span class="e Identifier"><span class="i">ret</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">getMethod</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDInstance</span></span><span class="t Pointer">*</span> <span class="i">inst</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="k">out</span> <span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">dummy</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">instance</span></span>.<span class="e Identifier"><span class="i">getField</span></span></span>(<span class="i">inst</span>, <span class="i">name</span>, <span class="i">dummy</span>)</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">dummy</span></span> == <span class="e Call"><span class="e Identifier"><span class="i">MDValue</span></span>(<span class="i">inst</span>)</span></span>)
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">proto</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">inst</span></span>.<span class="e Identifier"><span class="i">parent</span></span></span></span>;</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">dummy</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span></span>)</span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">proto</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">dummy</span></span>.<span class="e Identifier"><span class="i">mClass</span></span></span></span>;</span>
		}</span></span>

		<span class="s Return"><span class="k">return</span> <span class="e Deref">*<span class="e Identifier"><span class="i">ret</span></span></span>;</span>
	}</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">getMethod</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDTable</span></span><span class="t Pointer">*</span> <span class="i">tab</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">table</span></span>.<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">tab</span>, <span class="i">MDValue</span>(<span class="i">name</span>))</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Deref">*<span class="e Identifier"><span class="i">ret</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">getMethod</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDNamespace</span></span><span class="t Pointer">*</span> <span class="i">ns</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">ns</span>, <span class="i">name</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Deref">*<span class="e Identifier"><span class="i">ret</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">getMethod</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Qualified"><span class="t Identifier"><span class="i">MDValue</span></span>.<span class="t Identifier"><span class="i">Type</span></span></span> <span class="i">type</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">name</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">mt</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMetatable</span></span>(<span class="i">t</span>, <span class="i">type</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">mt</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">mt</span>, <span class="i">name</span>)</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Deref">*<span class="e Identifier"><span class="i">ret</span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDFunction</span></span><span class="t Pointer">*</span> <span class="i">getMM</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">obj</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MM</span></span> <span class="i">method</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">dummy</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">obj</span>, <span class="i">method</span>, <span class="i">dummy</span>)</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDFunction</span></span><span class="t Pointer">*</span> <span class="i">getMM</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">obj</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MM</span></span> <span class="i">method</span></span>, <span class="o Parameter"><span class="k">out</span> <span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">name</span> = <span class="e Index"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">metaStrings</span></span></span>[<span class="e Identifier"><span class="i">method</span></span>]</span>;</span></span>

	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">obj</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMethod</span></span>(<span class="i">obj</span>.<span class="i">mInstance</span>, <span class="i">name</span>, <span class="i">proto</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span></span>)
				<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">mFunction</span></span></span>;</span>
			<span class="k">else</span>
				<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMethod</span></span>(<span class="i">obj</span>.<span class="i">mTable</span>, <span class="i">name</span>)</span>;</span></span>
			
			<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span></span>)
				<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">mFunction</span></span></span>;</span></span>

			<span class="s Goto"><span class="k">goto</span> <span class="k">default</span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMethod</span></span>(<span class="i">t</span>, <span class="i">obj</span>.<span class="i">type</span>, <span class="i">name</span>)</span>;</span></span>
			
			<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span></span>)
				<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">mFunction</span></span></span>;</span>
			<span class="k">else</span>
				<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span></span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Template"><span class="k">template</span> <span class="i">tryMMParams</span><span class="o TemplateParameters">(<span class="o TemplateValueParameter"><span class="t Integral"><span class="k">int</span></span> <span class="i">numParams</span></span>, <span class="o TemplateValueParameter"><span class="t Integral"><span class="k">int</span></span> <span class="i">n</span> = <span class="e Int"><span class="n">1</span></span></span>)</span>
<span class="d Compound">{
	<span class="d StaticIf"><span class="k">static</span> <span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">n</span></span> &lt;= <span class="e Identifier"><span class="i">numParams</span></span></span>)
		<span class="d StorageClass"><span class="k">const</span> <span class="d Variables"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">tryMMParams</span> = <span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Paren">(<span class="e Cond"><span class="e Rel"><span class="e Identifier"><span class="i">n</span></span> &gt; <span class="e Int"><span class="n">1</span></span></span> ? <span class="e String"><span class="sl">", "</span></span> : <span class="e String"><span class="sl">""</span></span></span>)</span> ~ <span class="e String"><span class="sl">"MDValue* src"</span></span></span> ~ <span class="e Dot"><span class="e Identifier"><span class="i">n</span></span>.<span class="e Identifier"><span class="i">stringof</span></span></span></span> ~ <span class="e TemplateInstance"><span class="i">tryMMParams</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">numParams</span></span>, <span class="e Plus"><span class="e Identifier"><span class="i">n</span></span> + <span class="e Int"><span class="n">1</span></span></span></span>)</span></span>;</span></span>
	<span class="k">else</span>
		<span class="d StorageClass"><span class="k">const</span> <span class="d Variables"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">tryMMParams</span> = <span class="e String"><span class="sl">""</span></span>;</span></span></span>
}</span></span>

<span class="d Template"><span class="k">template</span> <span class="i">tryMMSaves</span><span class="o TemplateParameters">(<span class="o TemplateValueParameter"><span class="t Integral"><span class="k">int</span></span> <span class="i">numParams</span></span>, <span class="o TemplateValueParameter"><span class="t Integral"><span class="k">int</span></span> <span class="i">n</span> = <span class="e Int"><span class="n">1</span></span></span>)</span>
<span class="d Compound">{
	<span class="d StaticIf"><span class="k">static</span> <span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">n</span></span> &lt;= <span class="e Identifier"><span class="i">numParams</span></span></span>)
		<span class="d StorageClass"><span class="k">const</span> <span class="d Variables"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">tryMMSaves</span> = <span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e String"><span class="sl">"\tauto srcsave"</span></span> ~ <span class="e Dot"><span class="e Identifier"><span class="i">n</span></span>.<span class="e Identifier"><span class="i">stringof</span></span></span></span> ~ <span class="e String"><span class="sl">" = *src"</span></span></span> ~ <span class="e Dot"><span class="e Identifier"><span class="i">n</span></span>.<span class="e Identifier"><span class="i">stringof</span></span></span></span> ~ <span class="e String"><span class="sl">";\n"</span></span></span> ~ <span class="e TemplateInstance"><span class="i">tryMMSaves</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">numParams</span></span>, <span class="e Plus"><span class="e Identifier"><span class="i">n</span></span> + <span class="e Int"><span class="n">1</span></span></span></span>)</span></span>;</span></span>
	<span class="k">else</span>
		<span class="d StorageClass"><span class="k">const</span> <span class="d Variables"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">tryMMSaves</span> = <span class="e String"><span class="sl">""</span></span>;</span></span></span>
}</span></span>

<span class="d Template"><span class="k">template</span> <span class="i">tryMMPushes</span><span class="o TemplateParameters">(<span class="o TemplateValueParameter"><span class="t Integral"><span class="k">int</span></span> <span class="i">numParams</span></span>, <span class="o TemplateValueParameter"><span class="t Integral"><span class="k">int</span></span> <span class="i">n</span> = <span class="e Int"><span class="n">1</span></span></span>)</span>
<span class="d Compound">{
	<span class="d StaticIf"><span class="k">static</span> <span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">n</span></span> &lt;= <span class="e Identifier"><span class="i">numParams</span></span></span>)
		<span class="d StorageClass"><span class="k">const</span> <span class="d Variables"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">tryMMPushes</span> = <span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e String"><span class="sl">"\tpush(t, srcsave"</span></span> ~ <span class="e Dot"><span class="e Identifier"><span class="i">n</span></span>.<span class="e Identifier"><span class="i">stringof</span></span></span></span> ~ <span class="e String"><span class="sl">");\n"</span></span></span> ~ <span class="e TemplateInstance"><span class="i">tryMMPushes</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">numParams</span></span>, <span class="e Plus"><span class="e Identifier"><span class="i">n</span></span> + <span class="e Int"><span class="n">1</span></span></span></span>)</span></span>;</span></span>
	<span class="k">else</span>
		<span class="d StorageClass"><span class="k">const</span> <span class="d Variables"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">tryMMPushes</span> = <span class="e String"><span class="sl">""</span></span>;</span></span></span>
}</span></span>

<span class="d Template"><span class="k">template</span> <span class="i">tryMMImpl</span><span class="o TemplateParameters">(<span class="o TemplateValueParameter"><span class="t Integral"><span class="k">int</span></span> <span class="i">numParams</span></span>, <span class="o TemplateValueParameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">hasDest</span></span>)</span>
<span class="d Compound">{
	<span class="d StorageClass"><span class="k">const</span> <span class="d Variables"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">tryMMImpl</span> =
	<span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e Cat"><span class="e String"><span class="sl">"bool tryMM(MDThread* t, MM mm, "</span></span> ~ <span class="e Paren">(<span class="e Cond"><span class="e Identifier"><span class="i">hasDest</span></span>? <span class="e String"><span class="sl">"MDValue* dest, "</span></span> : <span class="e String"><span class="sl">""</span></span></span>)</span></span> ~ <span class="e TemplateInstance"><span class="i">tryMMParams</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">numParams</span></span></span>)</span></span> ~ <span class="e String"><span class="sl">")\n"</span>
	<span class="sl">"{\n"</span>
	<span class="sl">"	MDClass* proto = null;"</span>
	<span class="sl">"	auto method = getMM(t, src1, mm, proto);\n"</span>
	<span class="sl">"\n"</span>
	<span class="sl">"	if(method is null)\n"</span>
	<span class="sl">"		return false;\n"</span>
	<span class="sl">"\n"</span></span></span>
	~
	<span class="e Paren">(<span class="e Cond"><span class="e Identifier"><span class="i">hasDest</span></span>?
		<span class="e String"><span class="sl">"	bool shouldLoad = void;\n"</span>
		<span class="sl">"	savePtr(t, dest, shouldLoad);\n"</span></span>
	:
		<span class="e String"><span class="sl">""</span></span></span>)</span></span>
	~
	<span class="e String"><span class="sl">"\n"</span></span></span>
	~ <span class="e TemplateInstance"><span class="i">tryMMSaves</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">numParams</span></span></span>)</span></span> ~
	<span class="e String"><span class="sl">"\n"</span>
	<span class="sl">"	auto funcSlot = pushFunction(t, method);\n"</span></span></span>
	~ <span class="e TemplateInstance"><span class="i">tryMMPushes</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">numParams</span></span></span>)</span></span> ~
	<span class="e String"><span class="sl">"	commonCall(t, funcSlot + t.stackBase, "</span></span></span> ~ <span class="e Paren">(<span class="e Cond"><span class="e Identifier"><span class="i">hasDest</span></span> ? <span class="e String"><span class="sl">"1"</span></span> : <span class="e String"><span class="sl">"0"</span></span></span>)</span></span> ~ <span class="e String"><span class="sl">", callPrologue(t, funcSlot + t.stackBase, "</span></span></span> ~ <span class="e Paren">(<span class="e Cond"><span class="e Identifier"><span class="i">hasDest</span></span> ? <span class="e String"><span class="sl">"1"</span></span> : <span class="e String"><span class="sl">"0"</span></span></span>)</span></span> ~ <span class="e String"><span class="sl">", "</span></span></span> ~ <span class="e Dot"><span class="e Identifier"><span class="i">numParams</span></span>.<span class="e Identifier"><span class="i">stringof</span></span></span></span> ~ <span class="e String"><span class="sl">", proto));\n"</span></span></span>
	~
	<span class="e Paren">(<span class="e Cond"><span class="e Identifier"><span class="i">hasDest</span></span>?
		<span class="e String"><span class="sl">"	if(shouldLoad)\n"</span>
		<span class="sl">"		loadPtr(t, dest);\n"</span>
		<span class="sl">"	*dest = t.stack[t.stackIndex - 1];\n"</span>
		<span class="sl">"	pop(t);\n"</span></span>
	:
		<span class="e String"><span class="sl">""</span></span></span>)</span></span>
	~
	<span class="e String"><span class="sl">"	return true;\n"</span>
	<span class="sl">"}"</span></span></span>;</span></span>
}</span></span>

<span class="d Template"><span class="k">template</span> <span class="i">tryMM_shim</span><span class="o TemplateParameters">(<span class="o TemplateValueParameter"><span class="t Integral"><span class="k">int</span></span> <span class="i">numParams</span></span>, <span class="o TemplateValueParameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">hasDest</span></span>)</span>
<span class="d Compound">{
	<span class="d Mixin"><span class="k">mixin</span>(<span class="e TemplateInstance"><span class="i">tryMMImpl</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">numParams</span></span>, <span class="t Identifier"><span class="i">hasDest</span></span></span>)</span>);</span>
}</span></span>

<span class="d Template"><span class="k">template</span> <span class="i">tryMM</span><span class="o TemplateParameters">(<span class="o TemplateValueParameter"><span class="t Integral"><span class="k">int</span></span> <span class="i">numParams</span></span>, <span class="o TemplateValueParameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">hasDest</span></span>)</span>
<span class="d Compound">{
	<span class="d StaticAssert"><span class="k">static</span> <span class="k">assert</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numParams</span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>, <span class="e String"><span class="sl">"Need at least one param"</span></span>);</span>
	<span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t Qualified"><span class="t TemplateInstance"><span class="i">tryMM_shim</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">numParams</span></span>, <span class="t Identifier"><span class="i">hasDest</span></span></span>)</span>.<span class="t Identifier"><span class="i">tryMM</span></span></span> <span class="i">tryMM</span>;</span></span>
}</span></span>

<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">callPrologue</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">slot</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numReturns</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numParams</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numParams</span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">func</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span>;</span></span>

	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">func</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">callPrologue2</span></span>(<span class="i">t</span>, <span class="i">func</span>.<span class="i">mFunction</span>, <span class="i">slot</span>, <span class="i">numReturns</span>, <span class="i">slot</span> + <span class="n">1</span>, <span class="i">numParams</span>, <span class="i">proto</span>)</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">cls</span> = <span class="e Dot"><span class="e Identifier"><span class="i">func</span></span>.<span class="e Identifier"><span class="i">mClass</span></span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">cls</span></span>.<span class="e Identifier"><span class="i">allocator</span></span></span>)
			<span class="s Compound">{
				<span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>) <span class="s Compound">{}</span> <span class="k">else</span>
				<span class="s Compound">{
					<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span>++</span>;</span>
					<span class="s ScopeGuard"><span class="k">scope</span>(<span class="i">exit</span>) <span class="s Expression"><span class="e PostDecr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span>--</span>;</span></span>
				}</span></span>

				<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">cls</span></span>.<span class="e Identifier"><span class="i">allocator</span></span></span></span>;</span>
				<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span> = <span class="e Identifier"><span class="i">cls</span></span></span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">rawCall</span></span>(<span class="i">t</span>, <span class="i">slot</span> - <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>)</span>;</span>

				<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isInstance</span></span></span>(<span class="i">t</span>, <span class="i">slot</span> - <span class="i">t</span>.<span class="i">stackBase</span>)</span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, <span class="i">slot</span> - <span class="i">t</span>.<span class="i">stackBase</span>)</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"class allocator expected to return an 'instance', not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
				}</span></span>
			}</span>
			<span class="k">else</span>
			<span class="s Compound">{
				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">inst</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">instance</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">cls</span>)</span>;</span></span>

				<span class="lc">// call any constructor</span>
				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ctor</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">classobj</span></span>.<span class="e Identifier"><span class="i">getField</span></span></span>(<span class="i">cls</span>, <span class="i">string</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="sl">"constructor"</span>))</span>;</span></span>

				<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">ctor</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
				<span class="s Compound">{
					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">ctor</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">ctor</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"class constructor expected to be a 'function', not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span></span>

					<span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>) <span class="s Compound">{}</span> <span class="k">else</span>
					<span class="s Compound">{
						<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span>++</span>;</span>
						<span class="s ScopeGuard"><span class="k">scope</span>(<span class="i">exit</span>) <span class="s Expression"><span class="e PostDecr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span>--</span>;</span></span>
					}</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">ctor</span></span>.<span class="e Identifier"><span class="i">mFunction</span></span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span> = <span class="e Identifier"><span class="i">inst</span></span></span>;</span>

					<span class="lc">// do this instead of rawCall so the proto is set correctly</span>
					<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Identifier"><span class="i">callPrologue</span></span>(<span class="i">t</span>, <span class="i">slot</span>, <span class="n">0</span>, <span class="i">numParams</span>, <span class="i">cls</span>)</span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">execute</span></span>(<span class="i">t</span>)</span>;</span></span>
				}</span></span>

				<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span> = <span class="e Identifier"><span class="i">inst</span></span></span>;</span>
			}</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">numReturns</span></span> == <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
				<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span></span>;</span>
			<span class="k">else</span>
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numReturns</span></span> &gt; <span class="e Int"><span class="n">1</span></span></span>)
					<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Identifier"><span class="i">numReturns</span></span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span></span>

				<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Dead</span></span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">shouldHalt</span></span></span> = <span class="e Bool"><span class="k">false</span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Identifier"><span class="i">numReturns</span></span></span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">t</span></span> <span class="k">is</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">mainThread</span></span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">curThread</span></span></span> = <span class="e Identifier"><span class="i">t</span></span></span>;</span></span>
				}</span>
				<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span> &lt; <span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Identifier"><span class="i">numReturns</span></span></span></span>)
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Identifier"><span class="i">numReturns</span></span></span></span>;</span>
				<span class="k">else</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span></span>;</span></span></span>
			}</span></span>

			<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Thread</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">thread</span> = <span class="e Dot"><span class="e Identifier"><span class="i">func</span></span>.<span class="e Identifier"><span class="i">mThread</span></span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">thread</span></span> <span class="k">is</span> <span class="e Identifier"><span class="i">t</span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Thread attempting to resume itself"</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">thread</span></span> <span class="k">is</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">mainThread</span></span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to resume VM's main thread"</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">thread</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Initial</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">thread</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Suspended</span></span></span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to resume a {} coroutine"</span>, <span class="i">stateString</span>(<span class="i">thread</span>))</span>;</span></span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ar</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushAR</span></span>(<span class="i">t</span>)</span>;</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">base</span></span></span> = <span class="e Identifier"><span class="i">slot</span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span> = <span class="e Identifier"><span class="i">slot</span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">returnSlot</span></span></span> = <span class="e Identifier"><span class="i">slot</span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">func</span></span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">numReturns</span></span></span> = <span class="e Identifier"><span class="i">numReturns</span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">proto</span></span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">numTailcalls</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">firstResult</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">numResults</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>

			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Identifier"><span class="i">slot</span></span></span>;</span>

			<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numRets</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

			<span class="s Try"><span class="s Catch"><span class="k">try</span>
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">thread</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Initial</span></span></span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkStack</span></span>(<span class="i">thread</span>, <span class="k">cast</span>(<span class="i">AbsStack</span>)(<span class="i">numParams</span> + <span class="n">1</span>))</span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">thread</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Int"><span class="n">1</span></span> .. <span class="e Plus"><span class="e Int"><span class="n">1</span></span> + <span class="e Identifier"><span class="i">numParams</span></span></span>]</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span> .. <span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span> + <span class="e Identifier"><span class="i">numParams</span></span></span>]</span></span>;</span>
					<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">thread</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> += <span class="e Identifier"><span class="i">numParams</span></span></span>;</span>
				}</span>
				<span class="k">else</span>
				<span class="s Compound">{
					<span class="lc">// Get rid of 'this'</span>
					<span class="s Expression"><span class="e PostDecr"><span class="e Identifier"><span class="i">numParams</span></span>--</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">saveResults</span></span>(<span class="i">thread</span>, <span class="i">t</span>, <span class="i">slot</span> + <span class="n">2</span>, <span class="i">numParams</span>)</span>;</span>
				}</span></span>

				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">savedState</span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span>;</span></span>
				<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Waiting</span></span></span></span>;</span>

				<span class="s ScopeGuard"><span class="k">scope</span>(<span class="i">exit</span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> = <span class="e Identifier"><span class="i">savedState</span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">curThread</span></span></span> = <span class="e Identifier"><span class="i">t</span></span></span>;</span>
				}</span></span>

				<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numRets</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">resume</span></span>(<span class="i">thread</span>, <span class="i">numParams</span>)</span></span>;</span>
			}</span>
			<span class="k">catch</span>(<span class="o Parameter"><span class="t Identifier"><span class="i">MDException</span></span> <span class="i">e</span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">false</span>)</span>;</span>
				<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span>
			}</span></span></span>
			<span class="lc">// Don't have to handle halt exceptions; they can't propagate out of a thread</span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">saveResults</span></span>(<span class="i">t</span>, <span class="i">thread</span>, <span class="i">thread</span>.<span class="i">stackIndex</span> - <span class="i">numRets</span>, <span class="i">numRets</span>)</span>;</span>
			<span class="s Expression"><span class="e MinusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">thread</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> -= <span class="e Identifier"><span class="i">numRets</span></span></span>;</span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">true</span>)</span>;</span>
			<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">func</span>, <span class="i">MM</span>.<span class="i">Call</span>, <span class="i">proto</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">func</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"No implementation of {} for type '{}'"</span>, <span class="i">MetaNames</span>[<span class="i">MM</span>.<span class="i">Call</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">func</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">func</span></span></span> = <span class="e Identifier"><span class="i">method</span></span></span>;</span>
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">callPrologue2</span></span>(<span class="i">t</span>, <span class="i">method</span>, <span class="i">slot</span>, <span class="i">numReturns</span>, <span class="i">slot</span> + <span class="n">1</span>, <span class="i">numParams</span>, <span class="i">proto</span>)</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">callPrologue2</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDFunction</span></span><span class="t Pointer">*</span> <span class="i">func</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">returnSlot</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numReturns</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">paramSlot</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numParams</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Not">!<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span>)
	<span class="s Compound">{
		<span class="lc">// Script function</span>
		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">funcDef</span> = <span class="e Dot"><span class="e Identifier"><span class="i">func</span></span>.<span class="e Identifier"><span class="i">scriptFunc</span></span></span>;</span></span>
		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ar</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushAR</span></span>(<span class="i">t</span>)</span>;</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Dot"><span class="e Identifier"><span class="i">funcDef</span></span>.<span class="e Identifier"><span class="i">isVararg</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">numParams</span></span> &gt; <span class="e Dot"><span class="e Identifier"><span class="i">funcDef</span></span>.<span class="e Identifier"><span class="i">numParams</span></span></span></span></span>)
		<span class="s Compound">{
			<span class="lc">// In this case, we move the formal parameters after the varargs and null out where the formal</span>
			<span class="lc">// params used to be.</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">base</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">paramSlot</span></span> + <span class="e Identifier"><span class="i">numParams</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">paramSlot</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">funcDef</span></span>.<span class="e Identifier"><span class="i">numParams</span></span></span></span></span>;</span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkStack</span></span>(<span class="i">t</span>, <span class="i">ar</span>.<span class="i">base</span> + <span class="i">funcDef</span>.<span class="i">stackSize</span> - <span class="n">1</span>)</span>;</span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">oldParams</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">paramSlot</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">paramSlot</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">funcDef</span></span>.<span class="e Identifier"><span class="i">numParams</span></span></span></span>]</span>;</span></span>
			<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">base</span></span></span> .. <span class="e Plus"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">base</span></span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">funcDef</span></span>.<span class="e Identifier"><span class="i">numParams</span></span></span></span>]</span> = <span class="e Identifier"><span class="i">oldParams</span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">oldParams</span></span>[]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span>

			<span class="lc">// For nulling out the stack.</span>
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numParams</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">funcDef</span></span>.<span class="e Identifier"><span class="i">numParams</span></span></span></span>;</span>
		}</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="lc">// In this case, everything is where it needs to be already.</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">base</span></span></span> = <span class="e Identifier"><span class="i">paramSlot</span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span> = <span class="e Identifier"><span class="i">paramSlot</span></span></span>;</span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkStack</span></span>(<span class="i">t</span>, <span class="i">ar</span>.<span class="i">base</span> + <span class="i">funcDef</span>.<span class="i">stackSize</span> - <span class="n">1</span>)</span>;</span>

			<span class="lc">// Compensate for too many params.</span>
			<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numParams</span></span> &gt; <span class="e Dot"><span class="e Identifier"><span class="i">funcDef</span></span>.<span class="e Identifier"><span class="i">numParams</span></span></span></span>)
				<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numParams</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">funcDef</span></span>.<span class="e Identifier"><span class="i">numParams</span></span></span></span>;</span></span>

			<span class="lc">// If we have too few params, the extra param slots will be nulled out.</span>
		}</span></span>

		<span class="lc">// Null out the stack frame after the parameters.</span>
		<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">base</span></span></span> + <span class="e Identifier"><span class="i">numParams</span></span></span> .. <span class="e Plus"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">base</span></span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">funcDef</span></span>.<span class="e Identifier"><span class="i">stackSize</span></span></span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span>

		<span class="lc">// Fill in the rest of the activation record.</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">returnSlot</span></span></span> = <span class="e Identifier"><span class="i">returnSlot</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">func</span></span></span> = <span class="e Identifier"><span class="i">func</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">funcDef</span></span>.<span class="e Identifier"><span class="i">code</span></span></span>.<span class="e Identifier"><span class="i">ptr</span></span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">numReturns</span></span></span> = <span class="e Identifier"><span class="i">numReturns</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">firstResult</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">numResults</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">proto</span></span></span> = <span class="e Cond"><span class="e Identity"><span class="e Identifier"><span class="i">proto</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span> ? <span class="e Null"><span class="k">null</span></span> : <span class="e Dot"><span class="e Identifier"><span class="i">proto</span></span>.<span class="e Identifier"><span class="i">parent</span></span></span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">numTailcalls</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span> = <span class="e Plus"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">base</span></span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">funcDef</span></span>.<span class="e Identifier"><span class="i">stackSize</span></span></span></span></span>;</span>

		<span class="lc">// Set the stack indices.</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">base</span></span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span></span>;</span>
		
		<span class="lc">// Call any hook.</span>
		<span class="s Try"><span class="s Catch"><span class="k">try</span>
		<span class="s Compound">{
			<span class="s If"><span class="k">if</span>(<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hooks</span></span></span> &amp; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">Hook</span></span></span>.<span class="e Identifier"><span class="i">Call</span></span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callHook</span></span>(<span class="i">t</span>, <span class="i">MDThread</span>.<span class="i">Hook</span>.<span class="i">Call</span>)</span>;</span></span>
		}</span>
		<span class="k">catch</span>(<span class="o Parameter"><span class="t Identifier"><span class="i">MDException</span></span> <span class="i">e</span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">traceback</span></span></span>.<span class="e Identifier"><span class="i">append</span></span></span>(&amp;<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">getDebugLoc</span>(<span class="i">t</span>))</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">false</span>)</span>;</span>
			<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span>
		}</span></span>
		<span class="s Catch"><span class="k">catch</span>(<span class="o Parameter"><span class="t Identifier"><span class="i">MDHaltException</span></span> <span class="i">e</span></span>)
		<span class="s Compound">{
			<span class="lc">// TODO: investigate?</span>
			<span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>)
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">false</span>)</span>;</span>
					<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span>
				}</span></span>

				<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span>
			}</span>
			<span class="k">else</span>
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">false</span>)</span>;</span>
					<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span>
				}</span></span>

				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">saveResults</span></span>(<span class="i">t</span>, <span class="i">t</span>, <span class="k">cast</span>(<span class="i">AbsStack</span>)<span class="n">0</span>, <span class="n">0</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">true</span>)</span>;</span>

				<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
					<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span></span>

				<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span>
			}</span></span>
		}</span></span></span>

		<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="lc">// Native function</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">paramSlot</span></span> + <span class="e Identifier"><span class="i">numParams</span></span></span></span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkStack</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">stackIndex</span>)</span>;</span>
	
		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ar</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushAR</span></span>(<span class="i">t</span>)</span>;</span></span>
	
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">base</span></span></span> = <span class="e Identifier"><span class="i">paramSlot</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span> = <span class="e Identifier"><span class="i">paramSlot</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">returnSlot</span></span></span> = <span class="e Identifier"><span class="i">returnSlot</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">func</span></span></span> = <span class="e Identifier"><span class="i">func</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">numReturns</span></span></span> = <span class="e Identifier"><span class="i">numReturns</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">firstResult</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">numResults</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">proto</span></span></span> = <span class="e Cond"><span class="e Identity"><span class="e Identifier"><span class="i">proto</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span> ? <span class="e Null"><span class="k">null</span></span> : <span class="e Dot"><span class="e Identifier"><span class="i">proto</span></span>.<span class="e Identifier"><span class="i">parent</span></span></span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">numTailcalls</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>

		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">base</span></span></span></span>;</span>

		<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">actualReturns</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

		<span class="s Try"><span class="s Catch"><span class="k">try</span>
		<span class="s Compound">{
			<span class="s If"><span class="k">if</span>(<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hooks</span></span></span> &amp; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">Hook</span></span></span>.<span class="e Identifier"><span class="i">Call</span></span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callHook</span></span>(<span class="i">t</span>, <span class="i">MDThread</span>.<span class="i">Hook</span>.<span class="i">Call</span>)</span>;</span></span>

			<span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>) <span class="s Compound">{}</span> <span class="k">else</span>
			<span class="s Compound">{
				<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span>++</span>;</span>
				<span class="s ScopeGuard"><span class="k">scope</span>(<span class="i">exit</span>) <span class="s Expression"><span class="e PostDecr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span>--</span>;</span></span>
			}</span></span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">savedState</span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span>;</span></span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Running</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">curThread</span></span></span> = <span class="e Identifier"><span class="i">t</span></span></span>;</span>
			<span class="s ScopeGuard"><span class="k">scope</span>(<span class="i">exit</span>) <span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> = <span class="e Identifier"><span class="i">savedState</span></span></span>;</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">actualReturns</span></span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">func</span></span>.<span class="e Identifier"><span class="i">nativeFunc</span></span></span>(<span class="i">t</span>, <span class="i">numParams</span> - <span class="n">1</span>)</span></span>;</span>
		}</span>
		<span class="k">catch</span>(<span class="o Parameter"><span class="t Identifier"><span class="i">MDException</span></span> <span class="i">e</span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">traceback</span></span></span>.<span class="e Identifier"><span class="i">append</span></span></span>(&amp;<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">getDebugLoc</span>(<span class="i">t</span>))</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">false</span>)</span>;</span>
			<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span>
		}</span></span>
		<span class="s Catch"><span class="k">catch</span>(<span class="o Parameter"><span class="t Identifier"><span class="i">MDHaltException</span></span> <span class="i">e</span></span>)
		<span class="s Compound">{
			<span class="lc">// TODO: investigate?</span>
			<span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>)
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">false</span>)</span>;</span>
					<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span>
				}</span></span>

				<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span>
			}</span>
			<span class="k">else</span>
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">false</span>)</span>;</span>
					<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span>
				}</span></span>

				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">saveResults</span></span>(<span class="i">t</span>, <span class="i">t</span>, <span class="k">cast</span>(<span class="i">AbsStack</span>)<span class="n">0</span>, <span class="n">0</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">true</span>)</span>;</span>

				<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
					<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span></span>

				<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span>
			}</span></span>
		}</span></span></span>

		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">saveResults</span></span>(<span class="i">t</span>, <span class="i">t</span>, <span class="i">t</span>.<span class="i">stackIndex</span> - <span class="i">actualReturns</span>, <span class="i">actualReturns</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">true</span>)</span>;</span>
		<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">callEpilogue</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">needResults</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hooks</span></span></span> &amp; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">Hook</span></span></span>.<span class="e Identifier"><span class="i">Ret</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callReturnHooks</span></span>(<span class="i">t</span>)</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">destSlot</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">returnSlot</span></span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">numExpRets</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">numReturns</span></span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">results</span> = <span class="e Call"><span class="e Identifier"><span class="i">loadResults</span></span>(<span class="i">t</span>)</span>;</span></span>

	<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isMultRet</span> = <span class="e Bool"><span class="k">false</span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">numExpRets</span></span> == <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">isMultRet</span></span> = <span class="e Bool"><span class="k">true</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numExpRets</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">results</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
	}</span></span>
	
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">popAR</span></span>(<span class="i">t</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">needResults</span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">numYields</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">results</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>

		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">stk</span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>;</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numExpRets</span></span> &lt;= <span class="e Dot"><span class="e Identifier"><span class="i">results</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)
			<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">stk</span></span>[<span class="e Identifier"><span class="i">destSlot</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">destSlot</span></span> + <span class="e Identifier"><span class="i">numExpRets</span></span></span>]</span> = <span class="e Slice"><span class="e Identifier"><span class="i">results</span></span>[<span class="e Int"><span class="n">0</span></span> .. <span class="e Identifier"><span class="i">numExpRets</span></span>]</span></span>;</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">stk</span></span>[<span class="e Identifier"><span class="i">destSlot</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">destSlot</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">results</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>]</span> = <span class="e Slice"><span class="e Identifier"><span class="i">results</span></span>[]</span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">stk</span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">destSlot</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">results</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">destSlot</span></span> + <span class="e Identifier"><span class="i">numExpRets</span></span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span>
		}</span></span>
	}</span>
	<span class="k">else</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">numYields</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span></span>
		
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Dead</span></span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">shouldHalt</span></span></span> = <span class="e Bool"><span class="k">false</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">destSlot</span></span> + <span class="e Identifier"><span class="i">numExpRets</span></span></span></span>;</span>

		<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">t</span></span> <span class="k">is</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">mainThread</span></span></span></span>)
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">curThread</span></span></span> = <span class="e Identifier"><span class="i">t</span></span></span>;</span></span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Identifier"><span class="i">isMultRet</span></span> || <span class="e Rel"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span> &lt; <span class="e Plus"><span class="e Identifier"><span class="i">destSlot</span></span> + <span class="e Identifier"><span class="i">numExpRets</span></span></span></span></span>) <span class="lc">// second case happens in native -&gt; native calls</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">destSlot</span></span> + <span class="e Identifier"><span class="i">numExpRets</span></span></span></span>;</span>
	<span class="k">else</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span></span>;</span></span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">saveResults</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">from</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">first</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">num</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">num</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Return"><span class="k">return</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Paren">(<span class="e Minus"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">results</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">resultIndex</span></span></span></span>)</span> &lt; <span class="e Identifier"><span class="i">num</span></span></span>)
	<span class="s Compound">{
		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">newLen</span> = <span class="e Mul"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">results</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span> * <span class="e Int"><span class="n">2</span></span></span>;</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Minus"><span class="e Identifier"><span class="i">newLen</span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">resultIndex</span></span></span></span> &lt; <span class="e Identifier"><span class="i">num</span></span></span>)
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">newLen</span></span> = <span class="e Plus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">resultIndex</span></span></span> + <span class="e Identifier"><span class="i">num</span></span></span></span>;</span></span>

		<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">resizeArray</span></span></span>(<span class="i">t</span>.<span class="i">results</span>, <span class="i">newLen</span>)</span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e AndAnd"><span class="e Identity"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">firstResult</span></span></span> <span class="k">is</span> <span class="e Int"><span class="n">0</span></span></span> &amp;&amp; <span class="e Identity"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">numResults</span></span></span> <span class="k">is</span> <span class="e Int"><span class="n">0</span></span></span></span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tmp</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">from</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">first</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">first</span></span> + <span class="e Identifier"><span class="i">num</span></span></span>]</span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">results</span></span></span>[<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">resultIndex</span></span></span> .. <span class="e Plus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">resultIndex</span></span></span> + <span class="e Identifier"><span class="i">num</span></span></span>]</span> = <span class="e Identifier"><span class="i">tmp</span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">firstResult</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">resultIndex</span></span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">numResults</span></span></span> = <span class="e Identifier"><span class="i">num</span></span></span>;</span>

	<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">resultIndex</span></span></span> += <span class="e Identifier"><span class="i">num</span></span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Array">[]</span> <span class="i">loadResults</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">first</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">firstResult</span></span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">num</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">numResults</span></span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">results</span></span></span>[<span class="e Identifier"><span class="i">first</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">first</span></span> + <span class="e Identifier"><span class="i">num</span></span></span>]</span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">firstResult</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">numResults</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
	<span class="s Expression"><span class="e MinusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">resultIndex</span></span></span> -= <span class="e Identifier"><span class="i">num</span></span></span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span>
}</span></span></span>

<span class="lc">// ============================================================================</span>
<span class="lc">// Implementations</span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">toStringImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">v</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[<span class="e Int"><span class="n">80</span></span>]</span> <span class="i">buffer</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">"null"</span>)</span>;</span></span></span></span>
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Bool</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">v</span>.<span class="i">mBool</span> ? <span class="sl">"true"</span> : <span class="sl">"false"</span>)</span>;</span></span></span></span>
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span>:   <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">Integer</span>.<span class="i">format</span>(<span class="i">buffer</span>, <span class="i">v</span>.<span class="i">mInt</span>))</span>;</span></span></span></span>
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">vm</span>.<span class="i">formatter</span>.<span class="i">convertOne</span>(<span class="i">buffer</span>, <span class="k">typeid</span>(<span class="i">mdfloat</span>), &amp;<span class="i">v</span>.<span class="i">mFloat</span>))</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span><span class="t Array">[<span class="e Int"><span class="n">1</span></span>]</span> <span class="i">inbuf</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
			<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">inbuf</span></span>[<span class="e Int"><span class="n">0</span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mChar</span></span></span></span>;</span>
			<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">ate</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">Utf</span>.<span class="i">toString</span>(<span class="i">inbuf</span>, <span class="i">buffer</span>, &amp;<span class="i">ate</span>))</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">v</span>)</span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Not">!<span class="e Identifier"><span class="i">raw</span></span></span>)
			<span class="s Compound">{
				<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span>;</span></span>
				<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, &amp;<span class="i">v</span>, <span class="i">MM</span>.<span class="i">ToString</span>, <span class="i">proto</span>)</span></span></span></span>)
				<span class="s Compound">{
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">funcSlot</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">method</span>)</span>;</span></span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">v</span>)</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">funcSlot</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="i">callPrologue</span>(<span class="i">t</span>, <span class="i">funcSlot</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="n">1</span>, <span class="i">proto</span>))</span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isString</span></span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushTypeString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"toString was supposed to return a string, but returned a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span></span>

					<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
				}</span></span>
			}</span></span>

			<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
			<span class="s Compound">{
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"{} 0x{:X8}"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">Table</span>), <span class="k">cast</span>(<span class="k">void</span>*)<span class="i">v</span>.<span class="i">mTable</span>)</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"{} 0x{:X8}"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">Array</span>), <span class="k">cast</span>(<span class="k">void</span>*)<span class="i">v</span>.<span class="i">mArray</span>)</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">f</span> = <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mFunction</span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">f</span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span>)
						<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"native {} {}"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">Function</span>), <span class="i">f</span>.<span class="i">name</span>.<span class="i">toString</span>())</span>;</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">loc</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">f</span></span>.<span class="e Identifier"><span class="i">scriptFunc</span></span></span>.<span class="e Identifier"><span class="i">location</span></span></span>;</span></span>
						<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"script {} {}({}({}:{}))"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">Function</span>), <span class="i">f</span>.<span class="i">name</span>.<span class="i">toString</span>(), <span class="i">loc</span>.<span class="i">file</span>.<span class="i">toString</span>(), <span class="i">loc</span>.<span class="i">line</span>, <span class="i">loc</span>.<span class="i">col</span>)</span>;</span>
					}</span></span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span>:    <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"{} {} (0x{:X8})"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">Class</span>), <span class="i">v</span>.<span class="i">mClass</span>.<span class="i">name</span>.<span class="i">toString</span>(), <span class="k">cast</span>(<span class="k">void</span>*)<span class="i">v</span>.<span class="i">mClass</span>)</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"{} of {} (0x{:X8})"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">Instance</span>), <span class="i">v</span>.<span class="i">mInstance</span>.<span class="i">parent</span>.<span class="i">name</span>.<span class="i">toString</span>(), <span class="k">cast</span>(<span class="k">void</span>*)<span class="i">v</span>.<span class="i">mInstance</span>)</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">raw</span></span>)
						<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"{} 0x{:X8}"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">Namespace</span>), <span class="k">cast</span>(<span class="k">void</span>*)<span class="i">v</span>.<span class="i">mNamespace</span>)</span>;</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">Namespace</span>))</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushChar</span></span>(<span class="i">t</span>, <span class="cl">' '</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNamespaceNamestring</span></span>(<span class="i">t</span>, <span class="i">v</span>.<span class="i">mNamespace</span>)</span>;</span>
						<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">cat</span></span>(<span class="i">t</span>, <span class="n">3</span>)</span>;</span>
					}</span></span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Thread</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"{} 0x{:X8}"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">Thread</span>), <span class="k">cast</span>(<span class="k">void</span>*)<span class="i">v</span>.<span class="i">mThread</span>)</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">NativeObj</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"{} 0x{:X8}"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">NativeObj</span>), <span class="k">cast</span>(<span class="k">void</span>*)<span class="i">v</span>.<span class="i">mNativeObj</span>.<span class="i">obj</span>)</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">WeakRef</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"{} 0x{:X8}"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">WeakRef</span>), <span class="k">cast</span>(<span class="k">void</span>*)<span class="i">v</span>.<span class="i">mWeakRef</span>)</span>;</span></span></span></span>

				<span class="s Default"><span class="k">default</span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span></span></span></span>
			}</span></span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">inImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">item</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">container</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">container</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">item</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">item</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can only use characters to look in strings, not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">string</span></span>.<span class="e Identifier"><span class="i">contains</span></span></span>(<span class="i">container</span>.<span class="i">mString</span>, <span class="i">item</span>.<span class="i">mChar</span>)</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">table</span></span>.<span class="e Identifier"><span class="i">contains</span></span></span>(<span class="i">container</span>.<span class="i">mTable</span>, *<span class="i">item</span>)</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">contains</span></span></span>(<span class="i">container</span>.<span class="i">mArray</span>, *<span class="i">item</span>)</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">item</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">item</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can only use strings to look in namespaces, not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">contains</span></span></span>(<span class="i">container</span>.<span class="i">mNamespace</span>, <span class="i">item</span>.<span class="i">mString</span>)</span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">container</span>, <span class="i">MM</span>.<span class="i">In</span>, <span class="i">proto</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">container</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"No implementation of {} for type '{}'"</span>, <span class="i">MetaNames</span>[<span class="i">MM</span>.<span class="i">In</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">containersave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">container</span></span></span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">itemsave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">item</span></span></span>;</span></span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">funcSlot</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">method</span>)</span>;</span></span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">containersave</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">itemsave</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">funcSlot</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="i">callPrologue</span>(<span class="i">t</span>, <span class="i">funcSlot</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="n">2</span>, <span class="i">proto</span>))</span>;</span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">isTrue</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
			<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">idxImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">key</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">container</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">key</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">key</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to index an array with a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">index</span> = <span class="e Dot"><span class="e Identifier"><span class="i">key</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">arr</span> = <span class="e Dot"><span class="e Identifier"><span class="i">container</span></span>.<span class="e Identifier"><span class="i">mArray</span></span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span>)
				<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">index</span></span> += <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &gt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Invalid array index {} (length is {})"</span>, <span class="i">key</span>.<span class="i">mInt</span>, <span class="i">arr</span>.<span class="i">slice</span>.<span class="i">length</span>)</span>;</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>[<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">index</span></span></span>]</span></span>;</span>
			<span class="s Return"><span class="k">return</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">key</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">key</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to index a string with a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">index</span> = <span class="e Dot"><span class="e Identifier"><span class="i">key</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">str</span> = <span class="e Dot"><span class="e Identifier"><span class="i">container</span></span>.<span class="e Identifier"><span class="i">mString</span></span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span>)
				<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">index</span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">str</span></span>.<span class="e Identifier"><span class="i">cpLength</span></span></span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &gt;= <span class="e Dot"><span class="e Identifier"><span class="i">str</span></span>.<span class="e Identifier"><span class="i">cpLength</span></span></span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Invalid string index {} (length is {})"</span>, <span class="i">key</span>.<span class="i">mInt</span>, <span class="i">str</span>.<span class="i">cpLength</span>)</span>;</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">string</span></span>.<span class="e Identifier"><span class="i">charAt</span></span></span>(<span class="i">str</span>, <span class="k">cast</span>(<span class="i">uword</span>)<span class="i">index</span>)</span></span>;</span>
			<span class="s Return"><span class="k">return</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">tableIdxImpl</span></span>(<span class="i">t</span>, <span class="i">dest</span>, <span class="i">container</span>, <span class="i">key</span>, <span class="i">raw</span>)</span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Not">!<span class="e Identifier"><span class="i">raw</span></span></span> &amp;&amp; <span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">2</span></span>, <span class="e Bool"><span class="k">true</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Index</span>, <span class="i">dest</span>, <span class="i">container</span>, <span class="i">key</span>)</span></span>)
				<span class="s Return"><span class="k">return</span>;</span></span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">container</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to index a value of type '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">tableIdxImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">key</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">table</span></span>.<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">container</span>.<span class="i">mTable</span>, *<span class="i">key</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">v</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Deref">*<span class="e Identifier"><span class="i">v</span></span></span></span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">raw</span></span>)
			<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span>
		<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">container</span>, <span class="i">MM</span>.<span class="i">Index</span>)</span></span></span></span>)
		<span class="s Compound">{
			<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">bool</span></span> <span class="i">shouldLoad</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">savePtr</span></span>(<span class="i">t</span>, <span class="i">dest</span>, <span class="i">shouldLoad</span>)</span>;</span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">containersave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">container</span></span></span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">keysave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">key</span></span></span>;</span></span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">funcSlot</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">method</span>)</span>;</span></span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">containersave</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">keysave</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">rawCall</span></span>(<span class="i">t</span>, <span class="i">funcSlot</span>, <span class="n">1</span>)</span>;</span>

			<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">shouldLoad</span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">loadPtr</span></span>(<span class="i">t</span>, <span class="i">dest</span>)</span>;</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
		}</span>
		<span class="k">else</span>
			<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">idxaImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">key</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">value</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">container</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">key</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">key</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to index-assign an array with a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">index</span> = <span class="e Dot"><span class="e Identifier"><span class="i">key</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">arr</span> = <span class="e Dot"><span class="e Identifier"><span class="i">container</span></span>.<span class="e Identifier"><span class="i">mArray</span></span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span>)
				<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">index</span></span> += <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &gt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Invalid array index {} (length is {})"</span>, <span class="i">key</span>.<span class="i">mInt</span>, <span class="i">arr</span>.<span class="i">slice</span>.<span class="i">length</span>)</span>;</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>[<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">index</span></span></span>]</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">value</span></span></span></span>;</span>
			<span class="s Return"><span class="k">return</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">tableIdxaImpl</span></span>(<span class="i">t</span>, <span class="i">container</span>, <span class="i">key</span>, <span class="i">value</span>, <span class="i">raw</span>)</span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Not">!<span class="e Identifier"><span class="i">raw</span></span></span> &amp;&amp; <span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">3</span></span>, <span class="e Bool"><span class="k">false</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">IndexAssign</span>, <span class="i">container</span>, <span class="i">key</span>, <span class="i">value</span>)</span></span>)
				<span class="s Return"><span class="k">return</span>;</span></span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">container</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to index-assign a value of type '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">tableIdxaImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">key</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">value</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">key</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Not">!<span class="e Identifier"><span class="i">raw</span></span></span> &amp;&amp; <span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">3</span></span>, <span class="e Bool"><span class="k">false</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">IndexAssign</span>, <span class="i">container</span>, <span class="i">key</span>, <span class="i">value</span>)</span></span>)
			<span class="s Return"><span class="k">return</span>;</span></span>

		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to index-assign a table with a key of type 'null'"</span>)</span>;</span>
	}</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">table</span></span>.<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">container</span>.<span class="i">mTable</span>, *<span class="i">key</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">v</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">value</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>)
			<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">v</span></span></span> = <span class="e Deref">*<span class="e Identifier"><span class="i">value</span></span></span></span>;</span>
		<span class="k">else</span>
			<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">table</span></span>.<span class="e Identifier"><span class="i">remove</span></span></span>(<span class="i">container</span>.<span class="i">mTable</span>, *<span class="i">key</span>)</span>;</span></span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">value</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Identifier"><span class="i">raw</span></span> || <span class="e Call"><span class="e Not">!<span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">3</span></span>, <span class="e Bool"><span class="k">false</span></span></span>)</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">IndexAssign</span>, <span class="i">container</span>, <span class="i">key</span>, <span class="i">value</span>)</span></span>)
			<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">table</span></span>.<span class="e Identifier"><span class="i">set</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">container</span>.<span class="i">mTable</span>, *<span class="i">key</span>, *<span class="i">value</span>)</span>;</span></span>
	}</span></span></span>
	<span class="lc">// otherwise, do nothing (val is null and it doesn't exist)</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">commonField</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">slot</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">fieldImpl</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>], &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">container</span>], <span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>].<span class="i">mString</span>, <span class="i">raw</span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span> - <span class="e Int"><span class="n">1</span></span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">commonFielda</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">slot</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">2</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">fieldaImpl</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">container</span>], <span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>].<span class="i">mString</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span> + <span class="n">1</span>], <span class="i">raw</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>, <span class="n">2</span>)</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">fieldImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">container</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>:
			<span class="lc">// This is right, tables do not have separate opField capabilities.</span>
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">tableIdxImpl</span></span>(<span class="i">t</span>, <span class="i">dest</span>, <span class="i">container</span>, &amp;<span class="i">MDValue</span>(<span class="i">name</span>), <span class="i">raw</span>)</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">classobj</span></span>.<span class="e Identifier"><span class="i">getField</span></span></span>(<span class="i">container</span>.<span class="i">mClass</span>, <span class="i">name</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">v</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">container</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to access nonexistent field '{}' from '{}'"</span>, <span class="i">name</span>.<span class="i">toString</span>(), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Deref">*<span class="e Identifier"><span class="i">v</span></span></span></span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">instance</span></span>.<span class="e Identifier"><span class="i">getField</span></span></span>(<span class="i">container</span>.<span class="i">mInstance</span>, <span class="i">name</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">v</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Not">!<span class="e Identifier"><span class="i">raw</span></span></span> &amp;&amp; <span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">2</span></span>, <span class="e Bool"><span class="k">true</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Field</span>, <span class="i">dest</span>, <span class="i">container</span>, &amp;<span class="i">MDValue</span>(<span class="i">name</span>))</span></span>)
					<span class="s Return"><span class="k">return</span>;</span></span>

				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">container</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to access nonexistent field '{}' from '{}'"</span>, <span class="i">name</span>.<span class="i">toString</span>(), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Deref">*<span class="e Identifier"><span class="i">v</span></span></span></span>;</span></span></span></span>


		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">v</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">container</span>.<span class="i">mNamespace</span>, <span class="i">name</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">v</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Not">!<span class="e Identifier"><span class="i">raw</span></span></span> &amp;&amp; <span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">2</span></span>, <span class="e Bool"><span class="k">true</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Field</span>, <span class="i">dest</span>, <span class="i">container</span>, &amp;<span class="i">MDValue</span>(<span class="i">name</span>))</span></span>)
					<span class="s Return"><span class="k">return</span>;</span></span>

				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">toStringImpl</span></span>(<span class="i">t</span>, *<span class="i">container</span>, <span class="k">false</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to access nonexistent field '{}' from '{}'"</span>, <span class="i">name</span>.<span class="i">toString</span>(), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Deref">*<span class="e Identifier"><span class="i">v</span></span></span></span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Not">!<span class="e Identifier"><span class="i">raw</span></span></span> &amp;&amp; <span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">2</span></span>, <span class="e Bool"><span class="k">true</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Field</span>, <span class="i">dest</span>, <span class="i">container</span>, &amp;<span class="i">MDValue</span>(<span class="i">name</span>))</span></span>)
				<span class="s Return"><span class="k">return</span>;</span></span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">container</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to access field '{}' from a value of type '{}'"</span>, <span class="i">name</span>.<span class="i">toString</span>(), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">fieldaImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">value</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">bool</span></span> <span class="i">raw</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">container</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>:
			<span class="lc">// This is right, tables do not have separate opField capabilities.</span>
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">tableIdxaImpl</span></span>(<span class="i">t</span>, <span class="i">container</span>, &amp;<span class="i">MDValue</span>(<span class="i">name</span>), <span class="i">value</span>, <span class="i">raw</span>)</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">classobj</span></span>.<span class="e Identifier"><span class="i">setField</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">container</span>.<span class="i">mClass</span>, <span class="i">name</span>, <span class="i">value</span>)</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i</span> = <span class="e Dot"><span class="e Identifier"><span class="i">container</span></span>.<span class="e Identifier"><span class="i">mInstance</span></span></span>;</span></span>

			<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">owner</span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">field</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">instance</span></span>.<span class="e Identifier"><span class="i">getField</span></span></span>(<span class="i">i</span>, <span class="i">name</span>, <span class="i">owner</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">field</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Not">!<span class="e Identifier"><span class="i">raw</span></span></span> &amp;&amp; <span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">3</span></span>, <span class="e Bool"><span class="k">false</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">FieldAssign</span>, <span class="i">container</span>, &amp;<span class="i">MDValue</span>(<span class="i">name</span>), <span class="i">value</span>)</span></span>)
					<span class="s Return"><span class="k">return</span>;</span>
				<span class="k">else</span>
					<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">instance</span></span>.<span class="e Identifier"><span class="i">setField</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">i</span>, <span class="i">name</span>, <span class="i">value</span>)</span>;</span></span>
			}</span>
			<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">owner</span></span> != <span class="e Call"><span class="e Identifier"><span class="i">MDValue</span></span>(<span class="i">i</span>)</span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">instance</span></span>.<span class="e Identifier"><span class="i">setField</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">i</span>, <span class="i">name</span>, <span class="i">value</span>)</span>;</span>
			<span class="k">else</span>
				<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">field</span></span></span> = <span class="e Deref">*<span class="e Identifier"><span class="i">value</span></span></span></span>;</span></span></span>
			<span class="s Return"><span class="k">return</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">set</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">container</span>.<span class="i">mNamespace</span>, <span class="i">name</span>, <span class="i">value</span>)</span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Not">!<span class="e Identifier"><span class="i">raw</span></span></span> &amp;&amp; <span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">3</span></span>, <span class="e Bool"><span class="k">false</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">FieldAssign</span>, <span class="i">container</span>, &amp;<span class="i">MDValue</span>(<span class="i">name</span>), <span class="i">value</span>)</span></span>)
				<span class="s Return"><span class="k">return</span>;</span></span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">container</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to assign field '{}' into a value of type '{}'"</span>, <span class="i">name</span>.<span class="i">toString</span>(), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">compareImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">Compare3</span></span>(<span class="i">a</span>.<span class="i">mInt</span>, <span class="i">b</span>.<span class="i">mInt</span>)</span>;</span>
		<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">Compare3</span></span>(<span class="k">cast</span>(<span class="i">mdfloat</span>)<span class="i">a</span>.<span class="i">mInt</span>, <span class="i">b</span>.<span class="i">mFloat</span>)</span>;</span></span></span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">Compare3</span></span>(<span class="i">a</span>.<span class="i">mFloat</span>, <span class="k">cast</span>(<span class="i">mdfloat</span>)<span class="i">b</span>.<span class="i">mInt</span>)</span>;</span>
		<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">Compare3</span></span>(<span class="i">a</span>.<span class="i">mFloat</span>, <span class="i">b</span>.<span class="i">mFloat</span>)</span>;</span></span></span>
	}</span></span></span>

	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span>;</span></span>
	<span class="lc">// Don'_t put an else here.  SRSLY.</span>
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
		<span class="s Compound">{
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">0</span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Bool</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Paren">(<span class="e Minus"><span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">mdint</span></span>)<span class="e Identifier"><span class="i">a</span></span></span>.<span class="e Identifier"><span class="i">mBool</span></span></span> - <span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">mdint</span></span>)<span class="e Identifier"><span class="i">b</span></span></span>.<span class="e Identifier"><span class="i">mBool</span></span></span></span>)</span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">Compare3</span></span>(<span class="i">a</span>.<span class="i">mChar</span>, <span class="i">b</span>.<span class="i">mChar</span>)</span>;</span></span></span></span>

			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span>:
				<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">mString</span></span></span> <span class="k">is</span> <span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">mString</span></span></span></span>)
					<span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">0</span></span>;</span></span>

				<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">string</span></span>.<span class="e Identifier"><span class="i">compare</span></span></span>(<span class="i">a</span>.<span class="i">mString</span>, <span class="i">b</span>.<span class="i">mString</span>)</span>;</span></span></span></span>

			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>, <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span>:
				<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">a</span>, <span class="i">MM</span>.<span class="i">Cmp</span>, <span class="i">proto</span>)</span></span></span></span>)
					<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonCompare</span></span>(<span class="i">t</span>, <span class="i">method</span>, <span class="i">a</span>, <span class="i">b</span>, <span class="i">proto</span>)</span>;</span>
				<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">b</span>, <span class="i">MM</span>.<span class="i">Cmp</span>, <span class="i">proto</span>)</span></span></span></span>)
					<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Sign">-<span class="e Identifier"><span class="i">commonCompare</span></span></span>(<span class="i">t</span>, <span class="i">method</span>, <span class="i">b</span>, <span class="i">a</span>, <span class="i">proto</span>)</span>;</span></span></span>
				<span class="s Break"><span class="k">break</span>;</span></span></span></span> <span class="lc">// break to error</span>

			<span class="s Default"><span class="k">default</span>: <span class="s Scope"><span class="s Compound"><span class="s Break"><span class="k">break</span>;</span></span></span></span> <span class="lc">// break to error</span>
		}</span></span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Paren">(<span class="e OrOr"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> || <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span></span></span>)</span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">a</span>, <span class="i">MM</span>.<span class="i">Cmp</span>, <span class="i">proto</span>)</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonCompare</span></span>(<span class="i">t</span>, <span class="i">method</span>, <span class="i">a</span>, <span class="i">b</span>, <span class="i">proto</span>)</span>;</span></span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Paren">(<span class="e OrOr"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> || <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span></span></span>)</span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">b</span>, <span class="i">MM</span>.<span class="i">Cmp</span>, <span class="i">proto</span>)</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Sign">-<span class="e Identifier"><span class="i">commonCompare</span></span></span>(<span class="i">t</span>, <span class="i">method</span>, <span class="i">b</span>, <span class="i">a</span>, <span class="i">proto</span>)</span>;</span></span>
	}</span></span></span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bsave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">b</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">bsave</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can't compare types '{}' and '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">commonCompare</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDFunction</span></span><span class="t Pointer">*</span> <span class="i">method</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">b</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">asave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">a</span></span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bsave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">b</span></span></span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">funcReg</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">method</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">asave</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">bsave</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">funcReg</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="i">callPrologue</span>(<span class="i">t</span>, <span class="i">funcReg</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="n">2</span>, <span class="i">proto</span>))</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">getValue</span></span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">ret</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"{} is expected to return an int, but '{}' was returned instead"</span>, <span class="i">MetaNames</span>[<span class="i">MM</span>.<span class="i">Cmp</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">switchCmpImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">opEquals</span></span></span>(*<span class="i">b</span>)</span>)
		<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span></span>

	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> || <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">a</span>, <span class="i">MM</span>.<span class="i">Cmp</span>, <span class="i">proto</span>)</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">commonCompare</span></span>(<span class="i">t</span>, <span class="i">method</span>, <span class="i">a</span>, <span class="i">b</span>, <span class="i">proto</span>)</span> == <span class="e Int"><span class="n">0</span></span></span>;</span>
		<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">b</span>, <span class="i">MM</span>.<span class="i">Cmp</span>, <span class="i">proto</span>)</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">commonCompare</span></span>(<span class="i">t</span>, <span class="i">method</span>, <span class="i">b</span>, <span class="i">a</span>, <span class="i">proto</span>)</span> == <span class="e Int"><span class="n">0</span></span></span>;</span></span></span>
	}</span></span>
	
	<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">equalsImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">b</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span>
		<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Paren">(<span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">mdfloat</span></span>)<span class="e Identifier"><span class="i">a</span></span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>)</span> == <span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span></span>;</span></span></span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span> == <span class="e Paren">(<span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">mdfloat</span></span>)<span class="e Identifier"><span class="i">b</span></span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>)</span></span>;</span>
		<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span></span>;</span></span></span>
	}</span></span></span>
	
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span>;</span></span>
	<span class="lc">// Don'_t put an else here.  SRSLY.</span>
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
		<span class="s Compound">{
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span>:   <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Bool</span></span></span>:   <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">mBool</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">mBool</span></span></span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span>:   <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">mChar</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">mChar</span></span></span></span>;</span></span></span></span>
			<span class="lc">// Interning is fun.  We don'_t have to do a string comparison at all.</span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">mString</span></span></span> <span class="k">is</span> <span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">mString</span></span></span></span>;</span></span></span></span>

			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>, <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span>:
				<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">a</span>, <span class="i">MM</span>.<span class="i">Equals</span>, <span class="i">proto</span>)</span></span></span></span>)
					<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonEquals</span></span>(<span class="i">t</span>, <span class="i">method</span>, <span class="i">a</span>, <span class="i">b</span>, <span class="i">proto</span>)</span>;</span>
				<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">b</span>, <span class="i">MM</span>.<span class="i">Equals</span>, <span class="i">proto</span>)</span></span></span></span>)
					<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonEquals</span></span>(<span class="i">t</span>, <span class="i">method</span>, <span class="i">b</span>, <span class="i">a</span>, <span class="i">proto</span>)</span>;</span></span></span>
				<span class="s Break"><span class="k">break</span>;</span></span></span></span> <span class="lc">// break to error</span>

			<span class="s Default"><span class="k">default</span>: <span class="s Scope"><span class="s Compound"><span class="s Break"><span class="k">break</span>;</span></span></span></span> <span class="lc">// break to error</span>
		}</span></span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Paren">(<span class="e OrOr"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> || <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span></span></span>)</span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">a</span>, <span class="i">MM</span>.<span class="i">Equals</span>, <span class="i">proto</span>)</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonEquals</span></span>(<span class="i">t</span>, <span class="i">method</span>, <span class="i">a</span>, <span class="i">b</span>, <span class="i">proto</span>)</span>;</span></span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Paren">(<span class="e OrOr"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> || <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">b</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span></span></span>)</span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">b</span>, <span class="i">MM</span>.<span class="i">Equals</span>, <span class="i">proto</span>)</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonEquals</span></span>(<span class="i">t</span>, <span class="i">method</span>, <span class="i">b</span>, <span class="i">a</span>, <span class="i">proto</span>)</span>;</span></span>
	}</span></span></span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bsave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">b</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">a</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">bsave</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can't compare types '{}' and '{}' for equality"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">commonEquals</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDFunction</span></span><span class="t Pointer">*</span> <span class="i">method</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">b</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">asave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">a</span></span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">bsave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">b</span></span></span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">funcReg</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">method</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">asave</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">bsave</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">funcReg</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="i">callPrologue</span>(<span class="i">t</span>, <span class="i">funcReg</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="n">2</span>, <span class="i">proto</span>))</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">getValue</span></span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Bool</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">ret</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"{} is expected to return a bool, but '{}' was returned instead"</span>, <span class="i">MetaNames</span>[<span class="i">MM</span>.<span class="i">Equals</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">mBool</span></span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">lenImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">src</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span>:    <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">mdint</span></span>)<span class="e Identifier"><span class="i">src</span></span></span>.<span class="e Identifier"><span class="i">mString</span></span></span>.<span class="e Identifier"><span class="i">cpLength</span></span></span></span>;</span></span></span></span>
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span>:     <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">mdint</span></span>)<span class="e Identifier"><span class="i">src</span></span></span>.<span class="e Identifier"><span class="i">mArray</span></span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span></span></span></span>
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Call"><span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">mdint</span></span>)<span class="e Identifier"><span class="i">namespace</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span>(<span class="i">src</span>.<span class="i">mNamespace</span>)</span></span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">1</span></span>, <span class="e Bool"><span class="k">true</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Length</span>, <span class="i">dest</span>, <span class="i">src</span>)</span>)
				<span class="s Return"><span class="k">return</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span></span>)
				<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Call"><span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">mdint</span></span>)<span class="e Identifier"><span class="i">table</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span>(<span class="i">src</span>.<span class="i">mTable</span>)</span></span>;</span></span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">src</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can't get the length of a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">lenaImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">len</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">len</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">len</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to set the length of an array using a length of type '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">l</span> = <span class="e Dot"><span class="e Identifier"><span class="i">len</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">l</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to set the length of an array to a negative value ({})"</span>, <span class="i">l</span>)</span>;</span></span>

			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">resize</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">dest</span>.<span class="i">mArray</span>, <span class="k">cast</span>(<span class="i">uword</span>)<span class="i">l</span>)</span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">2</span></span>, <span class="e Bool"><span class="k">false</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">LengthAssign</span>, <span class="i">dest</span>, <span class="i">len</span>)</span>)
				<span class="s Return"><span class="k">return</span>;</span></span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">dest</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can't set the length of a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">sliceImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">src</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">lo</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">hi</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">arr</span> = <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mArray</span></span></span>;</span></span>
			<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">loIndex</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
			<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">hiIndex</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">lo</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">hi</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span></span>)
				<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Deref">*<span class="e Identifier"><span class="i">src</span></span></span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">correctIndices</span></span></span>(<span class="i">loIndex</span>, <span class="i">hiIndex</span>, <span class="i">lo</span>, <span class="i">hi</span>, <span class="i">arr</span>.<span class="i">slice</span>.<span class="i">length</span>)</span>)
			<span class="s Compound">{
				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">hisave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">hi</span></span></span>;</span></span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">lo</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">hisave</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to slice an array with indices of type '{}' and '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e OrOr"><span class="e OrOr"><span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">loIndex</span></span> &gt; <span class="e Identifier"><span class="i">hiIndex</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">loIndex</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">loIndex</span></span> &gt; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">hiIndex</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">hiIndex</span></span> &gt; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Invalid slice indices [{} .. {}] (array length = {})"</span>, <span class="i">loIndex</span>, <span class="i">hiIndex</span>, <span class="i">arr</span>.<span class="i">slice</span>.<span class="i">length</span>)</span>;</span></span>

			<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">arr</span>, <span class="k">cast</span>(<span class="i">uword</span>)<span class="i">loIndex</span>, <span class="k">cast</span>(<span class="i">uword</span>)<span class="i">hiIndex</span>)</span></span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">str</span> = <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mString</span></span></span>;</span></span>
			<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">loIndex</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
			<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">hiIndex</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">lo</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">hi</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span></span>)
				<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Deref">*<span class="e Identifier"><span class="i">src</span></span></span></span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">correctIndices</span></span></span>(<span class="i">loIndex</span>, <span class="i">hiIndex</span>, <span class="i">lo</span>, <span class="i">hi</span>, <span class="i">str</span>.<span class="i">cpLength</span>)</span>)
			<span class="s Compound">{
				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">hisave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">hi</span></span></span>;</span></span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">lo</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">hisave</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to slice a string with indices of type '{}' and '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e OrOr"><span class="e OrOr"><span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">loIndex</span></span> &gt; <span class="e Identifier"><span class="i">hiIndex</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">loIndex</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">loIndex</span></span> &gt; <span class="e Dot"><span class="e Identifier"><span class="i">str</span></span>.<span class="e Identifier"><span class="i">cpLength</span></span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">hiIndex</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">hiIndex</span></span> &gt; <span class="e Dot"><span class="e Identifier"><span class="i">str</span></span>.<span class="e Identifier"><span class="i">cpLength</span></span></span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Invalid slice indices [{} .. {}] (string length = {})"</span>, <span class="i">loIndex</span>, <span class="i">hiIndex</span>, <span class="i">str</span>.<span class="i">cpLength</span>)</span>;</span></span>

			<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">string</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">str</span>, <span class="k">cast</span>(<span class="i">uword</span>)<span class="i">loIndex</span>, <span class="k">cast</span>(<span class="i">uword</span>)<span class="i">hiIndex</span>)</span></span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">3</span></span>, <span class="e Bool"><span class="k">true</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Slice</span>, <span class="i">dest</span>, <span class="i">src</span>, <span class="i">lo</span>, <span class="i">hi</span>)</span>)
				<span class="s Return"><span class="k">return</span>;</span></span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">src</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to slice a value of type '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">sliceaImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">container</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">lo</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">hi</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">value</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">container</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">arr</span> = <span class="e Dot"><span class="e Identifier"><span class="i">container</span></span>.<span class="e Identifier"><span class="i">mArray</span></span></span>;</span></span>
			<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">loIndex</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
			<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">hiIndex</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
			
			<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">correctIndices</span></span></span>(<span class="i">loIndex</span>, <span class="i">hiIndex</span>, <span class="i">lo</span>, <span class="i">hi</span>, <span class="i">arr</span>.<span class="i">slice</span>.<span class="i">length</span>)</span>)
			<span class="s Compound">{
				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">hisave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">hi</span></span></span>;</span></span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">lo</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">hisave</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to slice-assign an array with indices of type '{}' and '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e OrOr"><span class="e OrOr"><span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">loIndex</span></span> &gt; <span class="e Identifier"><span class="i">hiIndex</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">loIndex</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">loIndex</span></span> &gt; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">hiIndex</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">hiIndex</span></span> &gt; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Invalid slice-assign indices [{} .. {}] (array length = {})"</span>, <span class="i">loIndex</span>, <span class="i">hiIndex</span>, <span class="i">arr</span>.<span class="i">slice</span>.<span class="i">length</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">value</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span>)
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Paren">(<span class="e Minus"><span class="e Identifier"><span class="i">hiIndex</span></span> - <span class="e Identifier"><span class="i">loIndex</span></span></span>)</span> != <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">value</span></span>.<span class="e Identifier"><span class="i">mArray</span></span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Array slice-assign lengths do not match (destination is {}, source is {})"</span>, <span class="i">hiIndex</span> - <span class="i">loIndex</span>, <span class="i">value</span>.<span class="i">mArray</span>.<span class="i">slice</span>.<span class="i">length</span>)</span>;</span></span>

				<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">sliceAssign</span></span></span>(<span class="i">arr</span>, <span class="k">cast</span>(<span class="i">uword</span>)<span class="i">loIndex</span>, <span class="k">cast</span>(<span class="i">uword</span>)<span class="i">hiIndex</span>, <span class="i">value</span>.<span class="i">mArray</span>)</span>;</span>
			}</span>
			<span class="k">else</span>
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">value</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to slice-assign a value of type '{}' into an array"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">4</span></span>, <span class="e Bool"><span class="k">false</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">SliceAssign</span>, <span class="i">container</span>, <span class="i">lo</span>, <span class="i">hi</span>, <span class="i">value</span>)</span>)
				<span class="s Return"><span class="k">return</span>;</span></span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">container</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to slice-assign a value of type '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">binOpImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MM</span></span> <span class="i">operation</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">RS</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">RT</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">mdfloat</span></span> <span class="i">f1</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">mdfloat</span></span> <span class="i">f2</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
		<span class="s Compound">{
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i1</span> = <span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i2</span> = <span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>

			<span class="s Switch"><span class="k">switch</span>(<span class="e Identifier"><span class="i">operation</span></span>)
			<span class="s Compound">{
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Add</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">i1</span></span> + <span class="e Identifier"><span class="i">i2</span></span></span></span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Sub</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Minus"><span class="e Identifier"><span class="i">i1</span></span> - <span class="e Identifier"><span class="i">i2</span></span></span></span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Mul</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Mul"><span class="e Identifier"><span class="i">i1</span></span> * <span class="e Identifier"><span class="i">i2</span></span></span></span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Mod</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">i2</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Integer modulo by zero"</span>)</span>;</span></span>

					<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Mod"><span class="e Identifier"><span class="i">i1</span></span> % <span class="e Identifier"><span class="i">i2</span></span></span></span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Div</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">i2</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Integer divide by zero"</span>)</span>;</span></span>

					<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Div"><span class="e Identifier"><span class="i">i1</span></span> / <span class="e Identifier"><span class="i">i2</span></span></span></span>;</span></span></span></span>

				<span class="s Default"><span class="k">default</span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span></span></span></span>
			}</span></span>
		}</span>
		<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">f1</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">f2</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span></span>;</span>
			<span class="s Goto"><span class="k">goto</span> <span class="i">_float</span>;</span>
		}</span></span></span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">f1</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">f2</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span>
			<span class="s Goto"><span class="k">goto</span> <span class="i">_float</span>;</span>
		}</span>
		<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">f1</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">f2</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span></span>;</span>

			<span class="s Labeled"><span class="i">_float</span>:
			<span class="s Switch"><span class="k">switch</span>(<span class="e Identifier"><span class="i">operation</span></span>)
			<span class="s Compound">{
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Add</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">f1</span></span> + <span class="e Identifier"><span class="i">f2</span></span></span></span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Sub</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Minus"><span class="e Identifier"><span class="i">f1</span></span> - <span class="e Identifier"><span class="i">f2</span></span></span></span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Mul</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Mul"><span class="e Identifier"><span class="i">f1</span></span> * <span class="e Identifier"><span class="i">f2</span></span></span></span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Div</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Div"><span class="e Identifier"><span class="i">f1</span></span> / <span class="e Identifier"><span class="i">f2</span></span></span></span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Mod</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Mod"><span class="e Identifier"><span class="i">f1</span></span> % <span class="e Identifier"><span class="i">f2</span></span></span></span>;</span></span></span></span>

				<span class="s Default"><span class="k">default</span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span></span></span></span>
			}</span></span></span>
		}</span></span></span>
	}</span></span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonBinOpMM</span></span>(<span class="i">t</span>, <span class="i">operation</span>, <span class="i">dest</span>, <span class="i">RS</span>, <span class="i">RT</span>)</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">commonBinOpMM</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MM</span></span> <span class="i">operation</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">RS</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">RT</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">bool</span></span> <span class="i">swap</span> = <span class="e Bool"><span class="k">false</span></span>;</span></span>
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">RS</span>, <span class="i">operation</span>, <span class="i">proto</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">method</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">RT</span>, <span class="i">MMRev</span>[<span class="i">operation</span>], <span class="i">proto</span>)</span></span>;</span>

		<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">swap</span></span> = <span class="e Bool"><span class="k">true</span></span></span>;</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="s If"><span class="k">if</span>(<span class="e Index"><span class="e Not">!<span class="e Identifier"><span class="i">MMCommutative</span></span></span>[<span class="e Identifier"><span class="i">operation</span></span>]</span>)
			<span class="s Compound">{
				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">RTsave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">RT</span></span></span>;</span></span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">RS</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RTsave</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Cannot perform the arithmetic operation '{}' on a '{}' and a '{}'"</span>, <span class="i">MetaNames</span>[<span class="i">operation</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">method</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">RS</span>, <span class="i">MMRev</span>[<span class="i">operation</span>], <span class="i">proto</span>)</span></span>;</span>

			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">method</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">RT</span>, <span class="i">operation</span>, <span class="i">proto</span>)</span></span>;</span>

				<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
				<span class="s Compound">{
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">RTsave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">RT</span></span></span>;</span></span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">RS</span>)</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RTsave</span>)</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Cannot perform the arithmetic operation '{}' on a '{}' and a '{}'"</span>, <span class="i">MetaNames</span>[<span class="i">operation</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
				}</span></span>

				<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">swap</span></span> = <span class="e Bool"><span class="k">true</span></span></span>;</span>
			}</span></span>
		}</span></span>
	}</span></span>

	<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">bool</span></span> <span class="i">shouldLoad</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">savePtr</span></span>(<span class="i">t</span>, <span class="i">dest</span>, <span class="i">shouldLoad</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">RSsave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">RS</span></span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">RTsave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">RT</span></span></span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">funcSlot</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">method</span>)</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">swap</span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">RTsave</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">RSsave</span>)</span>;</span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">RSsave</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">RTsave</span>)</span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">funcSlot</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="i">callPrologue</span>(<span class="i">t</span>, <span class="i">funcSlot</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="n">2</span>, <span class="i">proto</span>))</span>;</span>
	
	<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">shouldLoad</span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">loadPtr</span></span>(<span class="i">t</span>, <span class="i">dest</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">reflBinOpImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MM</span></span> <span class="i">operation</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">src</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">mdfloat</span></span> <span class="i">f1</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">mdfloat</span></span> <span class="i">f2</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
		<span class="s Compound">{
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i2</span> = <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>

			<span class="s Switch"><span class="k">switch</span>(<span class="e Identifier"><span class="i">operation</span></span>)
			<span class="s Compound">{
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">AddEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e PlusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> += <span class="e Identifier"><span class="i">i2</span></span></span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">SubEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e MinusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> -= <span class="e Identifier"><span class="i">i2</span></span></span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">MulEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e MulAssign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> *= <span class="e Identifier"><span class="i">i2</span></span></span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">ModEq</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">i2</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Integer modulo by zero"</span>)</span>;</span></span>

					<span class="s Return"><span class="k">return</span> <span class="e ModAssign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> %= <span class="e Identifier"><span class="i">i2</span></span></span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">DivEq</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">i2</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Integer divide by zero"</span>)</span>;</span></span>

					<span class="s Return"><span class="k">return</span> <span class="e DivAssign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> /= <span class="e Identifier"><span class="i">i2</span></span></span>;</span></span></span></span>

				<span class="s Default"><span class="k">default</span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span></span></span></span>
			}</span></span>
		}</span>
		<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">f1</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">f2</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span></span>;</span>
			<span class="s Goto"><span class="k">goto</span> <span class="i">_float</span>;</span>
		}</span></span></span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">f1</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">f2</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span>
			<span class="s Goto"><span class="k">goto</span> <span class="i">_float</span>;</span>
		}</span>
		<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">f1</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">f2</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span></span>;</span>

			<span class="s Labeled"><span class="i">_float</span>:
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>;</span></span>

			<span class="s Switch"><span class="k">switch</span>(<span class="e Identifier"><span class="i">operation</span></span>)
			<span class="s Compound">{
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">AddEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">f1</span></span> + <span class="e Identifier"><span class="i">f2</span></span></span></span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">SubEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span> = <span class="e Minus"><span class="e Identifier"><span class="i">f1</span></span> - <span class="e Identifier"><span class="i">f2</span></span></span></span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">MulEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span> = <span class="e Mul"><span class="e Identifier"><span class="i">f1</span></span> * <span class="e Identifier"><span class="i">f2</span></span></span></span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">DivEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span> = <span class="e Div"><span class="e Identifier"><span class="i">f1</span></span> / <span class="e Identifier"><span class="i">f2</span></span></span></span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">ModEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span> = <span class="e Mod"><span class="e Identifier"><span class="i">f1</span></span> % <span class="e Identifier"><span class="i">f2</span></span></span></span>;</span></span></span></span>

				<span class="s Default"><span class="k">default</span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span></span></span></span>
			}</span></span>
		}</span></span></span>
	}</span></span></span>
	
	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">2</span></span>, <span class="e Bool"><span class="k">false</span></span></span>)</span>(<span class="i">t</span>, <span class="i">operation</span>, <span class="i">dest</span>, <span class="i">src</span>)</span>)
		<span class="s Return"><span class="k">return</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">srcsave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">src</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">dest</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">srcsave</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Cannot perform the reflexive arithmetic operation '{}' on a '{}' and a '{}'"</span>, <span class="i">MetaNames</span>[<span class="i">operation</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">negImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">src</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Dot"><span class="e Sign">-<span class="e Identifier"><span class="i">src</span></span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Dot"><span class="e Sign">-<span class="e Identifier"><span class="i">src</span></span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span></span>;</span></span></span>
		
	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">1</span></span>, <span class="e Bool"><span class="k">true</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Neg</span>, <span class="i">dest</span>, <span class="i">src</span>)</span>)
		<span class="s Return"><span class="k">return</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">src</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Cannot perform negation on a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">binaryBinOpImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MM</span></span> <span class="i">operation</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">RS</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">RT</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span></span>)
	<span class="s Compound">{
		<span class="s Switch"><span class="k">switch</span>(<span class="e Identifier"><span class="i">operation</span></span>)
		<span class="s Compound">{
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">And</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> &amp; <span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Or</span></span></span>:   <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Or"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> | <span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Xor</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Xor"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> ^ <span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Shl</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e LShift"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> &lt;&lt; <span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">Shr</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e RShift"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> &gt;&gt; <span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">UShr</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e URShift"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> &gt;&gt;&gt; <span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span></span>;</span></span></span></span>
			<span class="s Default"><span class="k">default</span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span></span></span></span>
		}</span></span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">commonBinOpMM</span></span>(<span class="i">t</span>, <span class="i">operation</span>, <span class="i">dest</span>, <span class="i">RS</span>, <span class="i">RT</span>)</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">reflBinaryBinOpImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MM</span></span> <span class="i">operation</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">src</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span></span>)
	<span class="s Compound">{
		<span class="s Switch"><span class="k">switch</span>(<span class="e Identifier"><span class="i">operation</span></span>)
		<span class="s Compound">{
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">AndEq</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e AndAssign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> &amp;= <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">OrEq</span></span></span>:   <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e OrAssign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> |= <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">XorEq</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e XorAssign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> ^= <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">ShlEq</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e LShiftAssign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> &lt;&lt;= <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">ShrEq</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e RShiftAssign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> &gt;&gt;= <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span></span></span></span>
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">MM</span></span>.<span class="e Identifier"><span class="i">UShrEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e URShiftAssign"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span> &gt;&gt;&gt;= <span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span></span></span></span>
			<span class="s Default"><span class="k">default</span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span></span></span></span>
		}</span></span>
	}</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">2</span></span>, <span class="e Bool"><span class="k">false</span></span></span>)</span>(<span class="i">t</span>, <span class="i">operation</span>, <span class="i">dest</span>, <span class="i">src</span>)</span>)
		<span class="s Return"><span class="k">return</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">srcsave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">src</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">dest</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">srcsave</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Cannot perform reflexive binary operation '{}' on a '{}' and a '{}'"</span>, <span class="i">MetaNames</span>[<span class="i">operation</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">comImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">src</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Dot"><span class="e Comp">~<span class="e Identifier"><span class="i">src</span></span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">1</span></span>, <span class="e Bool"><span class="k">true</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Com</span>, <span class="i">dest</span>, <span class="i">src</span>)</span>)
		<span class="s Return"><span class="k">return</span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">src</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Cannot perform bitwise complement on a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">incImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
		<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>++</span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
		<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span>++</span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">1</span></span>, <span class="e Bool"><span class="k">false</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Inc</span>, <span class="i">dest</span>)</span>)
			<span class="s Return"><span class="k">return</span>;</span></span>

		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">dest</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Cannot increment a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">decImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
		<span class="s Expression"><span class="e PostDecr"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>--</span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span></span>)
		<span class="s Expression"><span class="e PostDecr"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mFloat</span></span></span>--</span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e TemplateInstance"><span class="i">tryMM</span>!(<span class="o TemplateArguments"><span class="e Int"><span class="n">1</span></span>, <span class="e Bool"><span class="k">false</span></span></span>)</span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Dec</span>, <span class="i">dest</span>)</span>)
			<span class="s Return"><span class="k">return</span>;</span></span>

		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">dest</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Cannot decrement a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">catImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">firstSlot</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">num</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">slot</span> = <span class="e Identifier"><span class="i">firstSlot</span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">endSlot</span> = <span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Identifier"><span class="i">num</span></span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">endSlotm1</span> = <span class="e Minus"><span class="e Identifier"><span class="i">endSlot</span></span> - <span class="e Int"><span class="n">1</span></span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">stack</span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>;</span></span>

	<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">bool</span></span> <span class="i">shouldLoad</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">savePtr</span></span>(<span class="i">t</span>, <span class="i">dest</span>, <span class="i">shouldLoad</span>)</span>;</span>

	<span class="s While"><span class="k">while</span>(<span class="e Rel"><span class="e Identifier"><span class="i">slot</span></span> &lt; <span class="e Identifier"><span class="i">endSlotm1</span></span></span>)
	<span class="s Compound">{
		<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDFunction</span></span><span class="t Pointer">*</span> <span class="i">method</span> = <span class="e Null"><span class="k">null</span></span>;</span></span>
		<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span> = <span class="e Null"><span class="k">null</span></span>;</span></span>

		<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span>)
		<span class="s Compound">{
			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span>, <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span>:
				<span class="s Scope"><span class="s Compound"><span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">idx</span> = <span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>;</span></span>
				<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">len</span> = <span class="e Cond"><span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span></span> ? <span class="e Int"><span class="n">1</span></span> : <span class="e Dot"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span>.<span class="e Identifier"><span class="i">mString</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span></span>

				<span class="s For"><span class="k">for</span>(; <span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &lt; <span class="e Identifier"><span class="i">endSlot</span></span></span>; <span class="e PostIncr"><span class="e Identifier"><span class="i">idx</span></span>++</span>)
				<span class="s Compound">{
					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">idx</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
						<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">len</span></span> += <span class="e Dot"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">idx</span></span>]</span>.<span class="e Identifier"><span class="i">mString</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
					<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">idx</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span></span>)
						<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">len</span></span>++</span>;</span>
					<span class="k">else</span>
						<span class="s Break"><span class="k">break</span>;</span></span></span>
				}</span></span>

				<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &gt; <span class="e Paren">(<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">stringConcat</span></span>(<span class="i">t</span>, <span class="i">stack</span>[<span class="i">slot</span>], <span class="i">stack</span>[<span class="i">slot</span> + <span class="n">1</span> .. <span class="i">idx</span>], <span class="i">len</span>)</span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">slot</span></span> = <span class="e Minus"><span class="e Identifier"><span class="i">idx</span></span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span>
				}</span></span>

				<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">slot</span></span> == <span class="e Identifier"><span class="i">endSlotm1</span></span></span>)
					<span class="s Break"><span class="k">break</span>;</span></span> <span class="lc">// to exit function</span>

				<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span>)
					<span class="s Goto"><span class="k">goto</span> <span class="i">array</span>;</span>
				<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> || <span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span></span></span>)
					<span class="s Goto"><span class="k">goto</span> <span class="i">cat_r</span>;</span>
				<span class="k">else</span>
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">stack</span>[<span class="i">slot</span> + <span class="n">1</span>])</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can't concatenate 'string/char' and '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
				}</span></span></span></span></span></span>

			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span>:
				<span class="s Scope"><span class="s Compound"><span class="s Labeled"><span class="i">array</span>:
				<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">idx</span> = <span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>;</span></span></span>
				<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">len</span> = <span class="e Cond"><span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span> ? <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span>.<span class="e Identifier"><span class="i">mArray</span></span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span> : <span class="e Int"><span class="n">1</span></span></span>;</span></span>

				<span class="s For"><span class="k">for</span>(; <span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &lt; <span class="e Identifier"><span class="i">endSlot</span></span></span>; <span class="e PostIncr"><span class="e Identifier"><span class="i">idx</span></span>++</span>)
				<span class="s Compound">{
					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">idx</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span>)
						<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">len</span></span> += <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">idx</span></span>]</span>.<span class="e Identifier"><span class="i">mArray</span></span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
					<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">idx</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> || <span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">idx</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">method</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, &amp;<span class="i">stack</span>[<span class="i">idx</span>], <span class="i">MM</span>.<span class="i">Cat_r</span>, <span class="i">proto</span>)</span></span>;</span>

						<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
							<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">len</span></span>++</span>;</span>
						<span class="k">else</span>
							<span class="s Break"><span class="k">break</span>;</span></span>
					}</span>
					<span class="k">else</span>
						<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">len</span></span>++</span>;</span></span></span>
				}</span></span>

				<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &gt; <span class="e Paren">(<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">arrayConcat</span></span>(<span class="i">t</span>, <span class="i">stack</span>[<span class="i">slot</span> .. <span class="i">idx</span>], <span class="i">len</span>)</span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">slot</span></span> = <span class="e Minus"><span class="e Identifier"><span class="i">idx</span></span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span>
				}</span></span>

				<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">slot</span></span> == <span class="e Identifier"><span class="i">endSlotm1</span></span></span>)
					<span class="s Break"><span class="k">break</span>;</span></span> <span class="lc">// to exit function</span>

				<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)</span>;</span>
				<span class="s Goto"><span class="k">goto</span> <span class="i">cat_r</span>;</span></span></span></span>

			<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span>, <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>:
				<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">method</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, &amp;<span class="i">stack</span>[<span class="i">slot</span>], <span class="i">MM</span>.<span class="i">Cat</span>, <span class="i">proto</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
						<span class="s Goto"><span class="k">goto</span> <span class="i">array</span>;</span></span>
				}</span></span>

				<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">bool</span></span> <span class="i">swap</span> = <span class="e Bool"><span class="k">false</span></span>;</span></span>

				<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">method</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, &amp;<span class="i">stack</span>[<span class="i">slot</span>], <span class="i">MM</span>.<span class="i">Cat</span>, <span class="i">proto</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span></span></span>)
						<span class="s Compound">{
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">stack</span>[<span class="i">slot</span> + <span class="n">1</span>])</span>;</span>
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can't concatenate an 'instance/table' with a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
						}</span></span>

						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">method</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, &amp;<span class="i">stack</span>[<span class="i">slot</span> + <span class="n">1</span>], <span class="i">MM</span>.<span class="i">Cat_r</span>, <span class="i">proto</span>)</span></span>;</span>

						<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
						<span class="s Compound">{
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>])</span>;</span>
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span> + <span class="n">1</span>])</span>;</span>
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can't concatenate '{}' and '{}"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
						}</span></span>

						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">swap</span></span> = <span class="e Bool"><span class="k">true</span></span></span>;</span>
					}</span></span>
				}</span></span>

				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">src1save</span> = <span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span>;</span></span>
				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">src2save</span> = <span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span>;</span></span>

				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">funcSlot</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">method</span>)</span>;</span></span>

				<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">swap</span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">src2save</span>)</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">src1save</span>)</span>;</span>
				}</span>
				<span class="k">else</span>
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">src1save</span>)</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">src2save</span>)</span>;</span>
				}</span></span>

				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">funcSlot</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="i">callPrologue</span>(<span class="i">t</span>, <span class="i">funcSlot</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="n">2</span>, <span class="i">proto</span>))</span>;</span>

				<span class="lc">// stack might have changed.</span>
				<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">stack</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span></span>;</span>

				<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">slot</span></span>++</span>;</span>
				<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span> = <span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
				<span class="s Continue"><span class="k">continue</span>;</span></span></span></span>

			<span class="s Default"><span class="k">default</span>:
				<span class="lc">// Basic</span>
				<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span>)
					<span class="s Goto"><span class="k">goto</span> <span class="i">array</span>;</span>
				<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> || <span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span></span></span>)
					<span class="s Goto"><span class="k">goto</span> <span class="i">cat_r</span>;</span>
				<span class="k">else</span>
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>])</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span>])</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can't concatenate '{}' and '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
				}</span></span></span>

			<span class="s Labeled"><span class="i">cat_r</span>:
				<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">method</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, &amp;<span class="i">stack</span>[<span class="i">slot</span> + <span class="n">1</span>], <span class="i">MM</span>.<span class="i">Cat_r</span>, <span class="i">proto</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">slot</span> + <span class="n">1</span>])</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"No implementation of {} for type '{}'"</span>, <span class="i">MetaNames</span>[<span class="i">MM</span>.<span class="i">Cat_r</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span></span>
				}</span></span></span>

				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">objsave</span> = <span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span>;</span></span>
				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">valsave</span> = <span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span>;</span></span>

				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">funcSlot</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">method</span>)</span>;</span></span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">objsave</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">push</span></span>(<span class="i">t</span>, <span class="i">valsave</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">funcSlot</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="i">callPrologue</span>(<span class="i">t</span>, <span class="i">funcSlot</span> + <span class="i">t</span>.<span class="i">stackBase</span>, <span class="n">1</span>, <span class="n">2</span>, <span class="i">proto</span>))</span>;</span>

				<span class="lc">// stack might have changed.</span>
				<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">stack</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span></span>;</span>

				<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">slot</span></span>++</span>;</span>
				<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span> = <span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
				<span class="s Continue"><span class="k">continue</span>;</span></span></span></span>
		}</span></span>

		<span class="s Break"><span class="k">break</span>;</span>
	}</span></span>
	
	<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">shouldLoad</span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">loadPtr</span></span>(<span class="i">t</span>, <span class="i">dest</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">slot</span></span>]</span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">arrayConcat</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Array">[]</span> <span class="i">vals</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">len</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">vals</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> == <span class="e Int"><span class="n">2</span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">vals</span></span>[<span class="e Int"><span class="n">0</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">vals</span></span>[<span class="e Int"><span class="n">1</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">vals</span></span>[<span class="e Int"><span class="n">1</span></span>]</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">cat</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">vals</span>[<span class="n">0</span>].<span class="i">mArray</span>, <span class="i">vals</span>[<span class="n">1</span>].<span class="i">mArray</span>)</span></span>;</span>
		<span class="k">else</span>
			<span class="s Return"><span class="k">return</span> <span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">vals</span></span>[<span class="e Int"><span class="n">1</span></span>]</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">cat</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">vals</span>[<span class="n">0</span>].<span class="i">mArray</span>, &amp;<span class="i">vals</span>[<span class="n">1</span>])</span></span>;</span></span>
	}</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">len</span>)</span>;</span></span>

	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">i</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>

	<span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="k">ref</span> <span class="i">v</span></span></span>; <span class="e Identifier"><span class="i">vals</span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span>)
		<span class="s Compound">{
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">a</span> = <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mArray</span></span></span>;</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>[<span class="e Identifier"><span class="i">i</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">i</span></span> + <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>]</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>[]</span></span>;</span>
			<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">i</span></span> += <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
		}</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>[<span class="e Identifier"><span class="i">i</span></span>]</span> = <span class="e Identifier"><span class="i">v</span></span></span>;</span>
			<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">i</span></span>++</span>;</span>
		}</span></span>
	}</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">vals</span></span>[<span class="e Minus"><span class="e Dollar">$</span> - <span class="e Int"><span class="n">1</span></span></span>]</span> = <span class="e Identifier"><span class="i">ret</span></span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">stringConcat</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">first</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Array">[]</span> <span class="i">vals</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">len</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tmpBuffer</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e TemplateInstance"><span class="i">allocArray</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">char</span></span></span>)</span></span>(<span class="i">len</span>)</span>;</span></span>
	<span class="s ScopeGuard"><span class="k">scope</span>(<span class="i">exit</span>) <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">freeArray</span></span></span>(<span class="i">tmpBuffer</span>)</span>;</span></span>
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">i</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>

	<span class="s Declaration"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">add</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">v</span></span>)</span>
	<span class="s FuncBody"><span class="s Compound">{
		<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">s</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mString</span></span></span>.<span class="e Identifier"><span class="i">toString</span></span></span>()</span></span>;</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span><span class="t Array">[<span class="e Int"><span class="n">1</span></span>]</span> <span class="i">inbuf</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
			<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">inbuf</span></span>[<span class="e Int"><span class="n">0</span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mChar</span></span></span></span>;</span>
			<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[<span class="e Int"><span class="n">4</span></span>]</span> <span class="i">outbuf</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
			<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">ate</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">Utf</span></span>.<span class="e Identifier"><span class="i">toString</span></span></span>(<span class="i">inbuf</span>, <span class="i">outbuf</span>, &amp;<span class="i">ate</span>)</span></span>;</span>
		}</span></span>

		<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">tmpBuffer</span></span>[<span class="e Identifier"><span class="i">i</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">i</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>]</span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[]</span></span>;</span>
		<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">i</span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
	}</span></span></span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">add</span></span>(<span class="i">first</span>)</span>;</span>

	<span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="k">ref</span> <span class="i">v</span></span></span>; <span class="e Identifier"><span class="i">vals</span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">add</span></span>(<span class="i">v</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">vals</span></span>[<span class="e Minus"><span class="e Dollar">$</span> - <span class="e Int"><span class="n">1</span></span></span>]</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">string</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">tmpBuffer</span>)</span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">catEqImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">dest</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">firstSlot</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">num</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Rel"><span class="e Identifier"><span class="i">num</span></span> &gt;= <span class="e Int"><span class="n">1</span></span></span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">slot</span> = <span class="e Identifier"><span class="i">firstSlot</span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">endSlot</span> = <span class="e Plus"><span class="e Identifier"><span class="i">slot</span></span> + <span class="e Identifier"><span class="i">num</span></span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">stack</span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>;</span></span>

	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span>, <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">len</span> = <span class="e Cond"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span></span> ? <span class="e Int"><span class="n">1</span></span> : <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">dest</span></span>.<span class="e Identifier"><span class="i">mString</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span></span>

			<span class="s For"><span class="k">for</span>(<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">idx</span> = <span class="e Identifier"><span class="i">slot</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &lt; <span class="e Identifier"><span class="i">endSlot</span></span></span>; <span class="e PostIncr"><span class="e Identifier"><span class="i">idx</span></span>++</span>)
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">idx</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
					<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">len</span></span> += <span class="e Dot"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">idx</span></span>]</span>.<span class="e Identifier"><span class="i">mString</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
				<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Identifier"><span class="i">idx</span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span></span>)
					<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">len</span></span>++</span>;</span>
				<span class="k">else</span>
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">stack</span>[<span class="i">idx</span>])</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can't append a '{}' to a 'string/char'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
				}</span></span></span>
			}</span></span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">first</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span>;</span></span>
			<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">bool</span></span> <span class="i">shouldLoad</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">savePtr</span></span>(<span class="i">t</span>, <span class="i">dest</span>, <span class="i">shouldLoad</span>)</span>;</span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">stringConcat</span></span>(<span class="i">t</span>, <span class="i">first</span>, <span class="i">stack</span>[<span class="i">slot</span> .. <span class="i">endSlot</span>], <span class="i">len</span>)</span>;</span>

			<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">shouldLoad</span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">loadPtr</span></span>(<span class="i">t</span>, <span class="i">dest</span>)</span>;</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span> = <span class="e Index"><span class="e Identifier"><span class="i">stack</span></span>[<span class="e Minus"><span class="e Identifier"><span class="i">endSlot</span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
			<span class="s Return"><span class="k">return</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">arrayAppend</span></span>(<span class="i">t</span>, <span class="i">dest</span>.<span class="i">mArray</span>, <span class="i">stack</span>[<span class="i">slot</span> .. <span class="i">endSlot</span>])</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span>, <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span>;</span></span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">dest</span>, <span class="i">MM</span>.<span class="i">CatEq</span>, <span class="i">proto</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">dest</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"No implementation of {} for type '{}'"</span>, <span class="i">MetaNames</span>[<span class="i">MM</span>.<span class="i">CatEq</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
			}</span></span>

			<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">bool</span></span> <span class="i">shouldLoad</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">savePtr</span></span>(<span class="i">t</span>, <span class="i">dest</span>, <span class="i">shouldLoad</span>)</span>;</span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkStack</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">stackIndex</span>)</span>;</span>

			<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">shouldLoad</span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">loadPtr</span></span>(<span class="i">t</span>, <span class="i">dest</span>)</span>;</span></span>

			<span class="s For"><span class="k">for</span>(<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i</span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">i</span></span> &gt; <span class="e Identifier"><span class="i">firstSlot</span></span></span>; <span class="e PostDecr"><span class="e Identifier"><span class="i">i</span></span>--</span>)
				<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">i</span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Minus"><span class="e Identifier"><span class="i">i</span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">firstSlot</span></span>]</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">dest</span></span></span></span>;</span>

			<span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>) <span class="s Compound">{}</span> <span class="k">else</span>
			<span class="s Compound">{
				<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span>++</span>;</span>
				<span class="s ScopeGuard"><span class="k">scope</span>(<span class="i">exit</span>) <span class="s Expression"><span class="e PostDecr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span>--</span>;</span></span>
			}</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Identifier"><span class="i">callPrologue2</span></span>(<span class="i">t</span>, <span class="i">method</span>, <span class="i">firstSlot</span>, <span class="n">0</span>, <span class="i">firstSlot</span>, <span class="i">num</span> + <span class="n">1</span>, <span class="i">proto</span>)</span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">execute</span></span>(<span class="i">t</span>)</span>;</span></span>
			<span class="s Return"><span class="k">return</span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>:
			<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">dest</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can't append to a value of type '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">arrayAppend</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDArray</span></span><span class="t Pointer">*</span> <span class="i">a</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Array">[]</span> <span class="i">vals</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">len</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span>;</span></span>

	<span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="k">ref</span> <span class="i">val</span></span></span>; <span class="e Identifier"><span class="i">vals</span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">val</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span>)
			<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">len</span></span> += <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">val</span></span>.<span class="e Identifier"><span class="i">mArray</span></span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
		<span class="k">else</span>
			<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">len</span></span>++</span>;</span></span>
	}</span></span>

	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">i</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">resize</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">a</span>, <span class="i">len</span>)</span>;</span>

	<span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="k">ref</span> <span class="i">v</span></span></span>; <span class="e Identifier"><span class="i">vals</span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span></span>)
		<span class="s Compound">{
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">arr</span> = <span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mArray</span></span></span>;</span></span>
			<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>[<span class="e Identifier"><span class="i">i</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">i</span></span> + <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>]</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>[]</span></span>;</span>
			<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">i</span></span> += <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">arr</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
		}</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">slice</span></span></span>[<span class="e Identifier"><span class="i">i</span></span>]</span> = <span class="e Identifier"><span class="i">v</span></span></span>;</span>
			<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">i</span></span>++</span>;</span>
		}</span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">throwImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">ex</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">exSave</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">ex</span></span></span>;</span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushDebugLocStr</span></span>(<span class="i">t</span>, <span class="i">getDebugLoc</span>(<span class="i">t</span>))</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">": "</span>)</span>;</span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">size</span> = <span class="e Call"><span class="e Identifier"><span class="i">stackSize</span></span>(<span class="i">t</span>)</span>;</span></span>

	<span class="s Try"><span class="s Catch"><span class="k">try</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">toStringImpl</span></span>(<span class="i">t</span>, <span class="i">exSave</span>, <span class="k">false</span>)</span>;</span>
	<span class="k">catch</span>(<span class="o Parameter"><span class="t Identifier"><span class="i">MDException</span></span> <span class="i">e</span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">catchException</span></span>(<span class="i">t</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">setStackSize</span></span>(<span class="i">t</span>, <span class="i">size</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">toStringImpl</span></span>(<span class="i">t</span>, <span class="i">exSave</span>, <span class="k">true</span>)</span>;</span>
	}</span></span></span>

	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">cat</span></span>(<span class="i">t</span>, <span class="n">3</span>)</span>;</span>

	<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">resizeArray</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">traceback</span>, <span class="n">0</span>)</span>;</span>

	<span class="lc">// dup'ing since we're removing the only MiniD reference and handing it off to D</span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">msg</span> = <span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">getString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>.<span class="e Identifier"><span class="i">dup</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>

	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">exception</span></span></span> = <span class="e Identifier"><span class="i">exSave</span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">isThrowing</span></span></span> = <span class="e Bool"><span class="k">true</span></span></span>;</span>
	<span class="s Throw"><span class="k">throw</span> <span class="e New"><span class="k">new</span> <span class="t Identifier"><span class="i">MDException</span></span>(<span class="e Identifier"><span class="i">msg</span></span>)</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">importImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">dest</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushGlobal</span></span>(<span class="i">t</span>, <span class="sl">"modules"</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">field</span></span>(<span class="i">t</span>, -<span class="n">1</span>, <span class="sl">"load"</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">insertAndPop</span></span>(<span class="i">t</span>, -<span class="n">2</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNull</span></span>(<span class="i">t</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushStringObj</span></span>(<span class="i">t</span>, <span class="i">name</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">rawCall</span></span>(<span class="i">t</span>, -<span class="n">3</span>, <span class="n">1</span>)</span>;</span>
	
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isNamespace</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>)</span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">dest</span></span>]</span> = <span class="e Call"><span class="e Identifier"><span class="i">getNamespace</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span></span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">asImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">o</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">p</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">p</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">p</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to use 'as' with a '{}' instead of a 'class' as the type"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span>

	<span class="s Return"><span class="k">return</span> <span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">o</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> &amp;&amp; <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">instance</span></span>.<span class="e Identifier"><span class="i">derivesFrom</span></span></span>(<span class="i">o</span>.<span class="i">mInstance</span>, <span class="i">p</span>.<span class="i">mClass</span>)</span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">superOfImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">v</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">p</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mClass</span></span></span>.<span class="e Identifier"><span class="i">parent</span></span></span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">MDValue</span></span>(<span class="i">p</span>)</span>;</span>
		<span class="k">else</span>
			<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span>;</span></span>
	}</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">MDValue</span></span>(<span class="i">v</span>.<span class="i">mInstance</span>.<span class="i">parent</span>)</span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span></span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">p</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mNamespace</span></span></span>.<span class="e Identifier"><span class="i">parent</span></span></span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">MDValue</span></span>(<span class="i">p</span>)</span>;</span>
		<span class="k">else</span>
			<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span>;</span></span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">v</span>)</span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Can only get super of classes, instances, and namespaces, not values of type '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
	}</span></span></span></span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
}</span></span></span>

<span class="lc">// ============================================================================</span>
<span class="lc">// Helper functions</span>

<span class="d Function"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">lookupGlobal</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDString</span></span><span class="t Pointer">*</span> <span class="i">name</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDNamespace</span></span><span class="t Pointer">*</span> <span class="i">env</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s For"><span class="k">for</span>(<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ns</span> = <span class="e Identifier"><span class="i">env</span></span>;</span></span> <span class="e Identity"><span class="e Identifier"><span class="i">ns</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>; <span class="e Assign"><span class="e Identifier"><span class="i">ns</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">ns</span></span>.<span class="e Identifier"><span class="i">parent</span></span></span></span>)
		<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">glob</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">ns</span>, <span class="i">name</span>)</span></span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">glob</span></span>;</span></span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Null"><span class="k">null</span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">savePtr</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="k">ref</span> <span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">ptr</span></span>, <span class="o Parameter"><span class="k">out</span> <span class="t Integral"><span class="k">bool</span></span> <span class="i">shouldLoad</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">ptr</span></span> &gt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>.<span class="e Identifier"><span class="i">ptr</span></span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">ptr</span></span> &lt; <span class="e Plus"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>.<span class="e Identifier"><span class="i">ptr</span></span></span> + <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">shouldLoad</span></span> = <span class="e Bool"><span class="k">true</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">ptr</span></span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span>)<span class="e Paren">(<span class="e Minus"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">ptr</span></span></span> - <span class="e Dot"><span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>.<span class="e Identifier"><span class="i">ptr</span></span></span></span>)</span></span></span>;</span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">loadPtr</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="k">ref</span> <span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">ptr</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">ptr</span></span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span>)<span class="e Paren">(<span class="e Plus"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">ptr</span></span></span> + <span class="e Dot"><span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>.<span class="e Identifier"><span class="i">ptr</span></span></span></span>)</span></span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDNamespace</span></span><span class="t Pointer">*</span> <span class="i">getMetatable</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Qualified"><span class="t Identifier"><span class="i">MDValue</span></span>.<span class="t Identifier"><span class="i">Type</span></span></span> <span class="i">type</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">type</span></span> &gt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">type</span></span> &lt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">WeakRef</span></span></span></span></span>)</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Index"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">metaTabs</span></span></span>[<span class="e Identifier"><span class="i">type</span></span>]</span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">correctIndices</span><span class="o Parameters">(<span class="o Parameter"><span class="k">out</span> <span class="t Identifier"><span class="i">mdint</span></span> <span class="i">loIndex</span></span>, <span class="o Parameter"><span class="k">out</span> <span class="t Identifier"><span class="i">mdint</span></span> <span class="i">hiIndex</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">lo</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">hi</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">len</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">lo</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">loIndex</span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">lo</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">loIndex</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">lo</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span>

		<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">loIndex</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span>)
			<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">loIndex</span></span> += <span class="e Identifier"><span class="i">len</span></span></span>;</span></span>
	}</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span></span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">hi</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">hiIndex</span></span> = <span class="e Identifier"><span class="i">len</span></span></span>;</span>
	<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">hi</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">hiIndex</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">hi</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span></span>;</span>

		<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">hiIndex</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span>)
			<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">hiIndex</span></span> += <span class="e Identifier"><span class="i">len</span></span></span>;</span></span>
	}</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span></span></span>

	<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">pushNamespaceNamestring</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDNamespace</span></span><span class="t Pointer">*</span> <span class="i">ns</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">namespaceName</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDNamespace</span></span><span class="t Pointer">*</span> <span class="i">ns</span></span>)</span>
	<span class="s FuncBody"><span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">ns</span></span>.<span class="e Identifier"><span class="i">name</span></span></span>.<span class="e Identifier"><span class="i">cpLength</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">0</span></span>;</span></span>

		<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">n</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>

		<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">ns</span></span>.<span class="e Identifier"><span class="i">parent</span></span></span>)
		<span class="s Compound">{
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Identifier"><span class="i">namespaceName</span></span>(<span class="i">ns</span>.<span class="i">parent</span>)</span>;</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">ret</span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushChar</span></span>(<span class="i">t</span>, <span class="cl">'.'</span>)</span>;</span>
				<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">n</span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">ret</span></span> + <span class="e Int"><span class="n">1</span></span></span></span>;</span>
			}</span></span>
		}</span></span>

		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushStringObj</span></span>(<span class="i">t</span>, <span class="i">ns</span>.<span class="i">name</span>)</span>;</span>
		<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">n</span></span>++</span>;</span>

		<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">n</span></span>;</span>
	}</span></span></span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">x</span> = <span class="e Call"><span class="e Identifier"><span class="i">namespaceName</span></span>(<span class="i">ns</span>)</span>;</span></span>
	
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">x</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">""</span>)</span>;</span>
	<span class="k">else</span>
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">cat</span></span>(<span class="i">t</span>, <span class="i">x</span>)</span>;</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">word</span></span> <span class="i">typeString</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">v</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">type</span></span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Bool</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Float</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Char</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Table</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Array</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Thread</span></span></span>,
			<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">WeakRef</span></span></span>:
			
			<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">v</span>.<span class="i">type</span>))</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span>:
			<span class="lc">// LEAVE ME UP HERE PLZ, don't inline, thx.</span>
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">n</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mClass</span></span></span>.<span class="e Identifier"><span class="i">name</span></span></span>.<span class="e Identifier"><span class="i">toString</span></span></span>()</span>;</span></span>
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"{} {}"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">Class</span>), <span class="i">n</span>)</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span>:
			<span class="lc">// don't inline me either.</span>
			<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">n</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mInstance</span></span></span>.<span class="e Identifier"><span class="i">parent</span></span></span>.<span class="e Identifier"><span class="i">name</span></span></span>.<span class="e Identifier"><span class="i">toString</span></span></span>()</span>;</span></span>
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"{} of {}"</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">Instance</span>), <span class="i">n</span>)</span>;</span></span></span></span>

		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">NativeObj</span></span></span>:
			<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">MDValue</span>.<span class="i">typeString</span>(<span class="i">MDValue</span>.<span class="i">Type</span>.<span class="i">NativeObj</span>))</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushChar</span></span>(<span class="i">t</span>, <span class="cl">' '</span>)</span>;</span>

			<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">o</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">v</span></span>.<span class="e Identifier"><span class="i">mNativeObj</span></span></span>.<span class="e Identifier"><span class="i">obj</span></span></span></span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="i">o</span>.<span class="i">classinfo</span>.<span class="i">name</span>)</span>;</span>
			<span class="k">else</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">"(??? null)"</span>)</span>;</span></span>

			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">cat</span></span>(<span class="i">t</span>, <span class="n">3</span>)</span>;</span></span></span></span>

		<span class="s Default"><span class="k">default</span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span></span></span></span>
	}</span></span>
}</span></span></span>

<span class="lc">// ============================================================================</span>
<span class="lc">// Coroutines</span>

<span class="d Version"><span class="k">version</span>(<span class="i">MDRestrictedCoro</span>) <span class="d Compound">{}</span> <span class="k">else</span>
<span class="d Compound">{
	<span class="d Class"><span class="k">class</span> <span class="i">ThreadFiber</span> : <span class="t BaseClass"><span class="t Identifier"><span class="i">Fiber</span></span></span>
	<span class="d Compound">{
		<span class="d Variables"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span>;</span>

		<span class="d Constructor"><span class="k">this</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
		<span class="s FuncBody"><span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Super"><span class="k">super</span></span>(&amp;<span class="i">run</span>, <span class="n">16384</span>)</span>;</span> <span class="lc">// TODO: provide the stack size as a user-settable value</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e This"><span class="k">this</span></span>.<span class="e Identifier"><span class="i">t</span></span></span> = <span class="e Identifier"><span class="i">t</span></span></span>;</span>
		}</span></span></span>

		<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">run</span><span class="o Parameters">()</span>
		<span class="s FuncBody"><span class="s Compound">{
			<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Initial</span></span></span></span>)</span>;</span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">coroFunc</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">insert</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">rawCall</span></span>(<span class="i">t</span>, <span class="n">1</span>, -<span class="n">1</span>)</span>;</span>
		}</span></span></span>
	}</span></span>
}</span></span>

<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">yieldImpl</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">firstValue</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numReturns</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numValues</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ar</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushAR</span></span>(<span class="i">t</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> &gt; <span class="e Int"><span class="n">1</span></span></span>)</span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">ar</span></span></span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">actRecs</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> - <span class="e Int"><span class="n">2</span></span></span>]</span></span>;</span>

	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">func</span></span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">returnSlot</span></span></span> = <span class="e Identifier"><span class="i">firstValue</span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">numReturns</span></span></span> = <span class="e Identifier"><span class="i">numReturns</span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">firstResult</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ar</span></span>.<span class="e Identifier"><span class="i">numResults</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">numValues</span></span> == <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">numYields</span></span></span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Identifier"><span class="i">firstValue</span></span></span></span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">firstValue</span></span> + <span class="e Identifier"><span class="i">numValues</span></span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">numYields</span></span></span> = <span class="e Identifier"><span class="i">numValues</span></span></span>;</span>
	}</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Suspended</span></span></span></span>;</span>

	<span class="s Version"><span class="k">version</span>(<span class="i">MDRestrictedCoro</span>)
		<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span>
	<span class="k">else</span> <span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">Fiber</span></span>.<span class="e Identifier"><span class="i">yield</span></span></span>()</span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Running</span></span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">curThread</span></span></span> = <span class="e Identifier"><span class="i">t</span></span></span>;</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">true</span>)</span>;</span>
		<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">coroFunc</span></span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">Fiber</span></span>.<span class="e Identifier"><span class="i">yield</span></span></span>()</span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Running</span></span></span></span>;</span>
			<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">curThread</span></span></span> = <span class="e Identifier"><span class="i">t</span></span></span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">true</span>)</span>;</span>
			<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span>
		}</span>
		<span class="k">else</span>
			<span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span></span>
	}</span></span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">resume</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numParams</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Initial</span></span></span></span>)
		<span class="s Compound">{
			<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">coroFiber</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
				<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">coroFiber</span></span></span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">nativeobj</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="k">new</span> <span class="i">ThreadFiber</span>(<span class="i">t</span>))</span></span>;</span>
			<span class="k">else</span>
				<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Paren">(<span class="e Dot"><span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">ThreadFiber</span></span>)<span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">void</span></span><span class="t Pointer">*</span>)<span class="e Identifier"><span class="i">t</span></span></span></span>.<span class="e Identifier"><span class="i">coroFiber</span></span></span>.<span class="e Identifier"><span class="i">obj</span></span></span>)</span>.<span class="e Identifier"><span class="i">t</span></span></span> = <span class="e Identifier"><span class="i">t</span></span></span>;</span></span>
		}</span></span>

		<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">getFiber</span></span></span>()</span>.<span class="e Identifier"><span class="i">call</span></span></span>()</span>;</span>
		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">numYields</span></span></span>;</span>
	}</span>
	<span class="k">else</span> <span class="s Version"><span class="k">version</span>(<span class="i">MDRestrictedCoro</span>)
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Initial</span></span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">coroFunc</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">insert</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">result</span> = <span class="e Call"><span class="e Identifier"><span class="i">callPrologue</span></span>(<span class="i">t</span>, <span class="k">cast</span>(<span class="i">AbsStack</span>)<span class="n">1</span>, -<span class="n">1</span>, <span class="i">numParams</span>, <span class="k">null</span>)</span>;</span></span>
			<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">result</span></span> == <span class="e Bool"><span class="k">true</span></span></span>, <span class="e String"><span class="sl">"resume callPrologue must return true"</span></span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">execute</span></span>(<span class="i">t</span>)</span>;</span>
		}</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">true</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">execute</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">savedCallDepth</span>)</span>;</span>
		}</span></span>

		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">numYields</span></span></span>;</span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Initial</span></span></span></span>)
		<span class="s Compound">{
			<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">coroFunc</span></span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span>)
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">coroFiber</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">coroFiber</span></span></span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">nativeobj</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="k">new</span> <span class="i">ThreadFiber</span>(<span class="i">t</span>))</span></span>;</span>
				<span class="k">else</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Paren">(<span class="e Dot"><span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">ThreadFiber</span></span>)<span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">void</span></span><span class="t Pointer">*</span>)<span class="e Identifier"><span class="i">t</span></span></span></span>.<span class="e Identifier"><span class="i">coroFiber</span></span></span>.<span class="e Identifier"><span class="i">obj</span></span></span>)</span>.<span class="e Identifier"><span class="i">t</span></span></span> = <span class="e Identifier"><span class="i">t</span></span></span>;</span></span>

				<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">getFiber</span></span></span>()</span>.<span class="e Identifier"><span class="i">call</span></span></span>()</span>;</span>
			}</span>
			<span class="k">else</span>
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">coroFunc</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">insert</span></span>(<span class="i">t</span>, <span class="n">1</span>)</span>;</span>
				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">result</span> = <span class="e Call"><span class="e Identifier"><span class="i">callPrologue</span></span>(<span class="i">t</span>, <span class="k">cast</span>(<span class="i">AbsStack</span>)<span class="n">1</span>, -<span class="n">1</span>, <span class="i">numParams</span>, <span class="k">null</span>)</span>;</span></span>
				<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">result</span></span> == <span class="e Bool"><span class="k">true</span></span></span>, <span class="e String"><span class="sl">"resume callPrologue must return true"</span></span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">execute</span></span>(<span class="i">t</span>)</span>;</span>
			}</span></span>
		}</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">coroFunc</span></span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">coroFiber</span></span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">getFiber</span></span></span>()</span>.<span class="e Identifier"><span class="i">call</span></span></span>()</span>;</span>
			}</span>
			<span class="k">else</span>
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">true</span>)</span>;</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">execute</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">savedCallDepth</span>)</span>;</span>
			}</span></span>
		}</span></span>

		<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">numYields</span></span></span>;</span>
	}</span></span></span>
}</span></span></span>

<span class="lc">// ============================================================================</span>
<span class="lc">// Interpreter State</span>

<span class="d Function"><span class="t Identifier"><span class="i">ActRecord</span></span><span class="t Pointer">*</span> <span class="i">pushAR</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> &gt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">actRecs</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">resizeArray</span></span></span>(<span class="i">t</span>.<span class="i">actRecs</span>, <span class="i">t</span>.<span class="i">actRecs</span>.<span class="i">length</span> * <span class="n">2</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">actRecs</span></span></span>[<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span>]</span></span>;</span>
	<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span>++</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>;</span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">popAR</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e PostDecr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span>--</span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">proto</span></span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">actRecs</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">base</span></span></span></span>;</span>
	}</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">TryRecord</span></span><span class="t Pointer">*</span> <span class="i">pushTR</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">trIndex</span></span></span> &gt;= <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">tryRecs</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e Identifier"><span class="i">resizeArray</span></span></span>(<span class="i">t</span>.<span class="i">tryRecs</span>, <span class="i">t</span>.<span class="i">tryRecs</span>.<span class="i">length</span> * <span class="n">2</span>)</span>;</span></span>

	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentTR</span></span></span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">tryRecs</span></span></span>[<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">trIndex</span></span></span>]</span></span>;</span>
	<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">trIndex</span></span></span>++</span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentTR</span></span></span>;</span>
}</span></span></span>

<span class="d Protection"><span class="k">protected</span> <span class="d StorageClass"><span class="k">final</span> <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">popTR</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e PostDecr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">trIndex</span></span></span>--</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">trIndex</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentTR</span></span></span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">tryRecs</span></span></span>[<span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">trIndex</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
	<span class="k">else</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentTR</span></span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span></span>
}</span></span></span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">close</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">AbsStack</span></span> <span class="i">index</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">base</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">index</span></span>]</span>;</span></span>

	<span class="s For"><span class="k">for</span>(<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">uv</span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">upvalHead</span></span></span>;</span></span> <span class="e AndAnd"><span class="e Identity"><span class="e Identifier"><span class="i">uv</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">uv</span></span>.<span class="e Identifier"><span class="i">value</span></span></span> &gt;= <span class="e Identifier"><span class="i">base</span></span></span></span>; <span class="e Assign"><span class="e Identifier"><span class="i">uv</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">upvalHead</span></span></span></span>)
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">upvalHead</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">uv</span></span>.<span class="e Identifier"><span class="i">nextuv</span></span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">uv</span></span>.<span class="e Identifier"><span class="i">closedValue</span></span></span> = <span class="e Dot"><span class="e Deref">*<span class="e Identifier"><span class="i">uv</span></span></span>.<span class="e Identifier"><span class="i">value</span></span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">uv</span></span>.<span class="e Identifier"><span class="i">value</span></span></span> = <span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">uv</span></span></span>.<span class="e Identifier"><span class="i">closedValue</span></span></span></span>;</span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Identifier"><span class="i">MDUpval</span></span><span class="t Pointer">*</span> <span class="i">findUpvalue</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">num</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">slot</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">base</span></span></span> + <span class="e Identifier"><span class="i">num</span></span></span>]</span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">puv</span> = <span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">upvalHead</span></span></span>;</span></span>
	
	<span class="s For"><span class="k">for</span>(<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">uv</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">puv</span></span></span>;</span></span> <span class="e AndAnd"><span class="e Identity"><span class="e Identifier"><span class="i">uv</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">uv</span></span>.<span class="e Identifier"><span class="i">value</span></span></span> &gt;= <span class="e Identifier"><span class="i">slot</span></span></span></span>; <span class="e Comma"><span class="e Assign"><span class="e Identifier"><span class="i">puv</span></span> = <span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">uv</span></span></span>.<span class="e Identifier"><span class="i">nextuv</span></span></span></span>, <span class="e Assign"><span class="e Identifier"><span class="i">uv</span></span> = <span class="e Deref">*<span class="e Identifier"><span class="i">puv</span></span></span></span></span>)
		<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">uv</span></span>.<span class="e Identifier"><span class="i">value</span></span></span> <span class="k">is</span> <span class="e Identifier"><span class="i">slot</span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">uv</span></span>;</span></span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ret</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">alloc</span></span></span>.<span class="e TemplateInstance"><span class="i">allocate</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">MDUpval</span></span></span>)</span></span>()</span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">value</span></span></span> = <span class="e Identifier"><span class="i">slot</span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">ret</span></span>.<span class="e Identifier"><span class="i">nextuv</span></span></span> = <span class="e Deref">*<span class="e Identifier"><span class="i">puv</span></span></span></span>;</span>
	<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">puv</span></span></span> = <span class="e Identifier"><span class="i">ret</span></span></span>;</span>
	<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">ret</span></span>;</span>
}</span></span></span>

<span class="lc">// ============================================================================</span>
<span class="lc">// Debugging</span>

<span class="d Function"><span class="t Identifier"><span class="i">Location</span></span> <span class="i">getDebugLoc</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span> || <span class="e Identity"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span></span>)
		<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">Location</span></span>(<span class="i">string</span>.<span class="i">create</span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="sl">"&lt;no location available&gt;"</span>), <span class="n">0</span>, <span class="i">Location</span>.<span class="i">Type</span>.<span class="i">Unknown</span>)</span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushNamespaceNamestring</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">currentAR</span>.<span class="i">func</span>.<span class="i">environment</span>)</span>;</span>

		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">getString</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span> == <span class="e String"><span class="sl">""</span></span></span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">dup</span></span>(<span class="i">t</span>)</span>;</span>
		<span class="k">else</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushChar</span></span>(<span class="i">t</span>, <span class="cl">'.'</span>)</span>;</span></span>

		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushStringObj</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">currentAR</span>.<span class="i">func</span>.<span class="i">name</span>)</span>;</span>

		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">cat</span></span>(<span class="i">t</span>, <span class="n">3</span>)</span>;</span>
		<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">s</span> = <span class="e Call"><span class="e Identifier"><span class="i">getStringObj</span></span>(<span class="i">t</span>, -<span class="n">1</span>)</span>;</span></span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>

		<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span>)
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">Location</span></span>(<span class="i">s</span>, <span class="n">0</span>, <span class="i">Location</span>.<span class="i">Type</span>.<span class="i">Native</span>)</span>;</span>
		<span class="k">else</span>
			<span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">Location</span></span>(<span class="i">s</span>, <span class="i">getDebugLine</span>(<span class="i">t</span>), <span class="i">Location</span>.<span class="i">Type</span>.<span class="i">Script</span>)</span>;</span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">pushDebugLocStr</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="k">ref</span> <span class="t Identifier"><span class="i">Location</span></span> <span class="i">loc</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">loc</span></span>.<span class="e Identifier"><span class="i">col</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">Location</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Unknown</span></span></span></span>)
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">"&lt;no location available&gt;"</span>)</span>;</span>
	<span class="k">else</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushStringObj</span></span>(<span class="i">t</span>, <span class="i">loc</span>.<span class="i">file</span>)</span>;</span>

		<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">loc</span></span>.<span class="e Identifier"><span class="i">col</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">Location</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Native</span></span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">"(native)"</span>)</span>;</span>
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">cat</span></span>(<span class="i">t</span>, <span class="n">2</span>)</span>;</span>
		}</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushChar</span></span>(<span class="i">t</span>, <span class="cl">'('</span>)</span>;</span>

			<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">loc</span></span>.<span class="e Identifier"><span class="i">line</span></span></span> == <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushChar</span></span>(<span class="i">t</span>, <span class="cl">'?'</span>)</span>;</span>
			<span class="k">else</span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"{}"</span>, <span class="i">loc</span>.<span class="i">line</span>)</span>;</span></span>
				
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushChar</span></span>(<span class="i">t</span>, <span class="cl">')'</span>)</span>;</span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">cat</span></span>(<span class="i">t</span>, <span class="n">4</span>)</span>;</span>
		}</span></span>
	}</span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">callHook</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Qualified"><span class="t Identifier"><span class="i">MDThread</span></span>.<span class="t Identifier"><span class="i">Hook</span></span></span> <span class="i">hook</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Not">!<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">hooksEnabled</span></span></span>)
		<span class="s Return"><span class="k">return</span>;</span></span>

	<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Not">!<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">hookFunc</span></span></span>)
		<span class="s Return"><span class="k">return</span>;</span></span>

	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">savedTop</span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hooksEnabled</span></span></span> = <span class="e Bool"><span class="k">false</span></span></span>;</span>
	
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushFunction</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">hookFunc</span>)</span>;</span>
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushThread</span></span>(<span class="i">t</span>, <span class="i">t</span>)</span>;</span>

	<span class="s Switch"><span class="k">switch</span>(<span class="e Identifier"><span class="i">hook</span></span>)
	<span class="s Compound">{
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">Hook</span></span></span>.<span class="e Identifier"><span class="i">Call</span></span></span>:    <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">"call"</span>)</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">Hook</span></span></span>.<span class="e Identifier"><span class="i">Ret</span></span></span>:     <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">"ret"</span>)</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">Hook</span></span></span>.<span class="e Identifier"><span class="i">TailRet</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">"tailret"</span>)</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">Hook</span></span></span>.<span class="e Identifier"><span class="i">Delay</span></span></span>:   <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">"delay"</span>)</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
		<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">Hook</span></span></span>.<span class="e Identifier"><span class="i">Line</span></span></span>:    <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushString</span></span>(<span class="i">t</span>, <span class="sl">"line"</span>)</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
		<span class="s Default"><span class="k">default</span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span></span></span></span>
	}</span></span>

	<span class="s Try"><span class="k">try</span>
		<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">rawCall</span></span>(<span class="i">t</span>, -<span class="n">3</span>, <span class="n">0</span>)</span>;</span>
	<span class="k">finally</span>
	<span class="s Compound">{
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hooksEnabled</span></span></span> = <span class="e Bool"><span class="k">true</span></span></span>;</span>
		<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Identifier"><span class="i">savedTop</span></span></span>;</span>
	<span class="s Finally">}</span></span></span>
}</span></span></span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">callReturnHooks</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callHook</span></span>(<span class="i">t</span>, <span class="i">MDThread</span>.<span class="i">Hook</span>.<span class="i">Ret</span>)</span>;</span>

	<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Not">!<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span>)
		<span class="s For"><span class="k">for</span>(<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">i</span> = <span class="e Int"><span class="n">0</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">i</span></span> &lt; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">numTailcalls</span></span></span></span>; <span class="e PostIncr"><span class="e Identifier"><span class="i">i</span></span>++</span>)
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callHook</span></span>(<span class="i">t</span>, <span class="i">MDThread</span>.<span class="i">Hook</span>.<span class="i">TailRet</span>)</span>;</span></span></span>
}</span></span></span>

<span class="lc">// ============================================================================</span>
<span class="lc">// Main interpreter loop</span>

<span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">execute</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">MDThread</span></span><span class="t Pointer">*</span> <span class="i">t</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">depth</span> = <span class="e Int"><span class="n">1</span></span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDException</span></span> <span class="i">currentException</span> = <span class="e Null"><span class="k">null</span></span>;</span></span>
	<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isReturning</span> = <span class="e Bool"><span class="k">false</span></span>;</span></span>
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">RS</span>;</span></span>
	<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDValue</span></span> <span class="i">RT</span>;</span></span>

	<span class="s Labeled"><span class="i">_exceptionRetry</span>:
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">state</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Running</span></span></span></span>;</span></span>
	<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">curThread</span></span></span> = <span class="e Identifier"><span class="i">t</span></span></span>;</span>

	<span class="s Labeled"><span class="i">_reentry</span>:
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">stackBase</span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span>;</span></span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">constTable</span> = <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">scriptFunc</span></span></span>.<span class="e Identifier"><span class="i">constants</span></span></span>;</span></span>
	<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">env</span> = <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">environment</span></span></span>;</span></span>

	<span class="s Try"><span class="s Catch"><span class="k">try</span>
	<span class="s Compound">{
		<span class="s Declaration"><span class="d Function"><span class="t Identifier"><span class="i">MDValue</span></span><span class="t Pointer">*</span> <span class="i">get</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">uint</span></span> <span class="i">index</span></span>)</span>
		<span class="s FuncBody"><span class="s Compound">{
			<span class="s Switch"><span class="k">switch</span>(<span class="e And"><span class="e Identifier"><span class="i">index</span></span> &amp; <span class="e Dot"><span class="e Identifier"><span class="i">Instruction</span></span>.<span class="e Identifier"><span class="i">locMask</span></span></span></span>)
			<span class="s Compound">{
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Instruction</span></span>.<span class="e Identifier"><span class="i">locLocal</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Rel"><span class="e Paren">(<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Paren">(<span class="e And"><span class="e Identifier"><span class="i">index</span></span> &amp; <span class="e Dot"><span class="e Comp">~<span class="e Identifier"><span class="i">Instruction</span></span></span>.<span class="e Identifier"><span class="i">locMask</span></span></span></span>)</span></span>)</span> &lt; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>, <span class="e String"><span class="sl">"invalid based stack index"</span></span>)</span>;</span>
					<span class="s Return"><span class="k">return</span> <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Paren">(<span class="e And"><span class="e Identifier"><span class="i">index</span></span> &amp; <span class="e Dot"><span class="e Comp">~<span class="e Identifier"><span class="i">Instruction</span></span></span>.<span class="e Identifier"><span class="i">locMask</span></span></span></span>)</span></span>]</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Instruction</span></span>.<span class="e Identifier"><span class="i">locConst</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Index"><span class="e Address">&amp;<span class="e Identifier"><span class="i">constTable</span></span></span>[<span class="e And"><span class="e Identifier"><span class="i">index</span></span> &amp; <span class="e Dot"><span class="e Comp">~<span class="e Identifier"><span class="i">Instruction</span></span></span>.<span class="e Identifier"><span class="i">locMask</span></span></span></span>]</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Instruction</span></span>.<span class="e Identifier"><span class="i">locUpval</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Index"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">scriptUpvals</span></span></span>()</span>[<span class="e And"><span class="e Identifier"><span class="i">index</span></span> &amp; <span class="e Dot"><span class="e Comp">~<span class="e Identifier"><span class="i">Instruction</span></span></span>.<span class="e Identifier"><span class="i">locMask</span></span></span></span>]</span>.<span class="e Identifier"><span class="i">value</span></span></span>;</span></span></span></span>

				<span class="s Default"><span class="k">default</span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Paren">(<span class="e And"><span class="e Identifier"><span class="i">index</span></span> &amp; <span class="e Dot"><span class="e Identifier"><span class="i">Instruction</span></span>.<span class="e Identifier"><span class="i">locMask</span></span></span></span>)</span> == <span class="e Dot"><span class="e Identifier"><span class="i">Instruction</span></span>.<span class="e Identifier"><span class="i">locGlobal</span></span></span></span>, <span class="e String"><span class="sl">"get() location"</span></span>)</span>;</span>

					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">name</span> = <span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">constTable</span></span>[<span class="e And"><span class="e Identifier"><span class="i">index</span></span> &amp; <span class="e Dot"><span class="e Comp">~<span class="e Identifier"><span class="i">Instruction</span></span></span>.<span class="e Identifier"><span class="i">locMask</span></span></span></span>]</span>.<span class="e Identifier"><span class="i">mString</span></span></span>;</span></span>

					<span class="s For"><span class="k">for</span>(<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ns</span> = <span class="e Identifier"><span class="i">env</span></span>;</span></span> <span class="e Identity"><span class="e Identifier"><span class="i">ns</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>; <span class="e Assign"><span class="e Identifier"><span class="i">ns</span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">ns</span></span>.<span class="e Identifier"><span class="i">parent</span></span></span></span>)
						<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">glob</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">ns</span>, <span class="i">name</span>)</span></span></span></span>)
							<span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">glob</span></span>;</span></span></span>

					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to get nonexistent global '{}'"</span>, <span class="i">name</span>.<span class="i">toString</span>())</span>;</span></span></span></span>
			}</span></span>

			<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>)</span>;</span>
		}</span></span></span></span>
		
		<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">Instruction</span></span><span class="t Pointer">*</span> <span class="i">oldPC</span> = <span class="e Null"><span class="k">null</span></span>;</span></span>

		<span class="s While"><span class="k">while</span>(<span class="e Bool"><span class="k">true</span></span>)
		<span class="s Compound">{
			<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">shouldHalt</span></span></span>)
				<span class="s Throw"><span class="k">throw</span> <span class="e New"><span class="k">new</span> <span class="t Identifier"><span class="i">MDHaltException</span></span>()</span>;</span></span>

			<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">i</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>;</span></span>
			<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>++</span>;</span>

			<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hooksEnabled</span></span></span>)
			<span class="s Compound">{
				<span class="s If"><span class="k">if</span>(<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hooks</span></span></span> &amp; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">Hook</span></span></span>.<span class="e Identifier"><span class="i">Delay</span></span></span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookCounter</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
					<span class="s Expression"><span class="e PostDecr"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookCounter</span></span></span>--</span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookCounter</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookCounter</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hookDelay</span></span></span></span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callHook</span></span>(<span class="i">t</span>, <span class="i">MDThread</span>.<span class="i">Hook</span>.<span class="i">Delay</span>)</span>;</span>
					}</span></span>
				}</span></span>

				<span class="s If"><span class="k">if</span>(<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">hooks</span></span></span> &amp; <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">Hook</span></span></span>.<span class="e Identifier"><span class="i">Line</span></span></span></span>)
				<span class="s Compound">{
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">curPC</span> = <span class="e Minus"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>;</span></span>

					<span class="lc">// when oldPC is null, it means we've either just started executing this func,</span>
					<span class="lc">// or we've come back from a yield, or we've just caught an exception, or something</span>
					<span class="lc">// like that.</span>
					<span class="lc">// When curPC &lt; oldPC, we've jumped back, like to the beginning of a loop.</span>

					<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e OrOr"><span class="e Identity"><span class="e Identifier"><span class="i">curPC</span></span> <span class="k">is</span> <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">scriptFunc</span></span></span>.<span class="e Identifier"><span class="i">code</span></span></span>.<span class="e Identifier"><span class="i">ptr</span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">curPC</span></span> &lt; <span class="e Identifier"><span class="i">oldPC</span></span></span></span> || <span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">pcToLine</span></span>(<span class="i">t</span>.<span class="i">currentAR</span>, <span class="i">curPC</span>)</span> != <span class="e Call"><span class="e Identifier"><span class="i">pcToLine</span></span>(<span class="i">t</span>.<span class="i">currentAR</span>, <span class="i">curPC</span> - <span class="n">1</span>)</span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callHook</span></span>(<span class="i">t</span>, <span class="i">MDThread</span>.<span class="i">Hook</span>.<span class="i">Line</span>)</span>;</span></span>
				}</span></span>
			}</span></span>

			<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">oldPC</span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span></span>;</span>

			<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">opcode</span></span></span>)
			<span class="s Compound">{
				<span class="lc">// Binary Arithmetic</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Add</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Add</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Sub</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Sub</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Mul</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Mul</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Div</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Div</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Mod</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Mod</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="lc">// Unary Arithmetic</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Neg</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">negImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="lc">// Reflexive Arithmetic</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">AddEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">AddEq</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">SubEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">SubEq</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">MulEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">MulEq</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">DivEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">DivEq</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">ModEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">ModEq</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="lc">// Inc/Dec</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Inc</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">incImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Dec</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">decImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="lc">// Binary Bitwise</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">And</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">And</span>,  <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Or</span></span></span>:   <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Or</span>,   <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Xor</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Xor</span>,  <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Shl</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Shl</span>,  <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Shr</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">Shr</span>,  <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">UShr</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">binaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">UShr</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="lc">// Unary Bitwise</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Com</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">comImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="lc">// Reflexive Bitwise</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">AndEq</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">AndEq</span>,  <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">OrEq</span></span></span>:   <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">OrEq</span>,   <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">XorEq</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">XorEq</span>,  <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">ShlEq</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">ShlEq</span>,  <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">ShrEq</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">ShrEq</span>,  <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">UShrEq</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reflBinaryBinOpImpl</span></span>(<span class="i">t</span>, <span class="i">MM</span>.<span class="i">UShrEq</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="lc">// Data Transfer</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Move</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span></span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">MoveLocal</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span></span>]</span></span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">LoadConst</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>]</span> = <span class="e Index"><span class="e Identifier"><span class="i">constTable</span></span>[<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span> &amp; <span class="e Dot"><span class="e Comp">~<span class="e Identifier"><span class="i">Instruction</span></span></span>.<span class="e Identifier"><span class="i">locMask</span></span></span></span>]</span></span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">CondMove</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">RD</span> = <span class="e Call"><span class="e Identifier"><span class="i">get</span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RD</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">RD</span></span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span></span>;</span></span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">LoadBool</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">bool</span></span>)<span class="e Identifier"><span class="i">i</span></span></span>.<span class="e Identifier"><span class="i">rs</span></span></span></span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">LoadNull</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">LoadNulls</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">start</span> = <span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>;</span></span>
					<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">start</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">start</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">NewGlobal</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">name</span> = <span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">constTable</span></span>[<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rt</span></span></span> &amp; <span class="e Dot"><span class="e Comp">~<span class="e Identifier"><span class="i">Instruction</span></span></span>.<span class="e Identifier"><span class="i">locMask</span></span></span></span>]</span>.<span class="e Identifier"><span class="i">mString</span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">contains</span></span></span>(<span class="i">env</span>, <span class="i">name</span>)</span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to create global '{}' that already exists"</span>, <span class="i">name</span>.<span class="i">toString</span>())</span>;</span></span>

					<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">set</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">env</span>, <span class="i">name</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="lc">// Logical and Control Flow</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Import</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RS</span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RS</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Import expression must be a string value, not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span></span>

					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">importImpl</span></span>(<span class="i">t</span>, <span class="i">RS</span>.<span class="i">mString</span>, <span class="i">stackBase</span> + <span class="i">i</span>.<span class="i">rd</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Not</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Call"><span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">get</span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span>.<span class="e Identifier"><span class="i">isFalse</span></span></span>()</span></span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Cmp</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">jump</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>;</span></span>
					<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>++</span>;</span>

					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">cmpValue</span> = <span class="e Call"><span class="e Identifier"><span class="i">compareImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span>)
					<span class="s Compound">{
						<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">opcode</span></span></span>)
						<span class="s Compound">{
							<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Je</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">cmpValue</span></span> == <span class="e Int"><span class="n">0</span></span></span>) <span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span></span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
							<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Jle</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">cmpValue</span></span> &lt;= <span class="e Int"><span class="n">0</span></span></span>) <span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span></span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
							<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Jlt</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">cmpValue</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span>)  <span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span></span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
							<span class="s Default"><span class="k">default</span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>, <span class="e String"><span class="sl">"invalid 'cmp' jump"</span></span>)</span>;</span></span></span></span>
						}</span></span>
					}</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s Switch"><span class="k">switch</span>(<span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">opcode</span></span></span>)
						<span class="s Compound">{
							<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Je</span></span></span>:  <span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">cmpValue</span></span> != <span class="e Int"><span class="n">0</span></span></span>) <span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span></span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
							<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Jle</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">cmpValue</span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)  <span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span></span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
							<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Jlt</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">cmpValue</span></span> &gt;= <span class="e Int"><span class="n">0</span></span></span>) <span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span></span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
							<span class="s Default"><span class="k">default</span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>, <span class="e String"><span class="sl">"invalid 'cmp' jump"</span></span>)</span>;</span></span></span></span>
						}</span></span>
					}</span></span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Equals</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">jump</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>;</span></span>
					<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>++</span>;</span>

					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">cmpValue</span> = <span class="e Call"><span class="e Identifier"><span class="i">equalsImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">cmpValue</span></span> == <span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">bool</span></span>)<span class="e Identifier"><span class="i">jump</span></span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>)
						<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span></span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Cmp3</span></span></span>:
					<span class="lc">// Doing this to ensure evaluation of get(i.rd) happens _after_ compareImpl has executed</span>
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">val</span> = <span class="e Call"><span class="e Identifier"><span class="i">compareImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span></span>
					<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Identifier"><span class="i">val</span></span></span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">SwitchCmp</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">jump</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>;</span></span>
					<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>++</span>;</span>
					<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">opcode</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Je</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span> == <span class="e Int"><span class="n">1</span></span></span></span>, <span class="e String"><span class="sl">"invalid 'swcmp' jump"</span></span>)</span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Identifier"><span class="i">switchCmpImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>)
						<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span></span>

					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Is</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">jump</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>;</span></span>
					<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>++</span>;</span>
					<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">opcode</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Je</span></span></span></span>, <span class="e String"><span class="sl">"invalid 'is' jump"</span></span>)</span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Call"><span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">get</span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span>.<span class="e Identifier"><span class="i">opEquals</span></span></span>(*<span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span> == <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>)
						<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span></span>

					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">IsTrue</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">jump</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>;</span></span>
					<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>++</span>;</span>
					<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">opcode</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Je</span></span></span></span>, <span class="e String"><span class="sl">"invalid 'istrue' jump"</span></span>)</span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Call"><span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">get</span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span>.<span class="e Identifier"><span class="i">isFalse</span></span></span>()</span> != <span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">bool</span></span>)<span class="e Identifier"><span class="i">jump</span></span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>)
						<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span></span>

					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Jmp</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span></span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Switch</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">st</span> = <span class="e Index"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">scriptFunc</span></span></span>.<span class="e Identifier"><span class="i">switchTables</span></span></span>[<span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rt</span></span></span>]</span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="s Declaration"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">ptr</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">st</span></span>.<span class="e Identifier"><span class="i">offsets</span></span></span>.<span class="e Identifier"><span class="i">lookup</span></span></span>(*<span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span></span></span></span>)
						<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Deref">*<span class="e Identifier"><span class="i">ptr</span></span></span></span>;</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">st</span></span>.<span class="e Identifier"><span class="i">defaultOffset</span></span></span> == <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span>)
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Switch without default"</span>)</span>;</span></span>

						<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">st</span></span>.<span class="e Identifier"><span class="i">defaultOffset</span></span></span></span>;</span>
					}</span></span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Close</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">close</span></span>(<span class="i">t</span>, <span class="i">stackBase</span> + <span class="i">i</span>.<span class="i">rd</span>)</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">For</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">idx</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>]</span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">hi</span> = <span class="e Plus"><span class="e Identifier"><span class="i">idx</span></span> + <span class="e Int"><span class="n">1</span></span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">step</span> = <span class="e Plus"><span class="e Identifier"><span class="i">hi</span></span> + <span class="e Int"><span class="n">1</span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e OrOr"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">idx</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span> || <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">hi</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span></span> || <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">step</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Numeric for loop low, high, and step values must be integers"</span>)</span>;</span></span>

					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">intIdx</span> = <span class="e Dot"><span class="e Identifier"><span class="i">idx</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">intHi</span> = <span class="e Dot"><span class="e Identifier"><span class="i">hi</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">intStep</span> = <span class="e Dot"><span class="e Identifier"><span class="i">step</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">intStep</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Numeric for loop step value may not be 0"</span>)</span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">intIdx</span></span> &gt; <span class="e Identifier"><span class="i">intHi</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">intStep</span></span> &gt; <span class="e Int"><span class="n">0</span></span></span></span> || <span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">intIdx</span></span> &lt; <span class="e Identifier"><span class="i">intHi</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">intStep</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">intStep</span></span> = <span class="e Sign">-<span class="e Identifier"><span class="i">intStep</span></span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">intStep</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">idx</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">intIdx</span></span> + <span class="e Identifier"><span class="i">intStep</span></span></span></span>;</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">step</span></span></span> = <span class="e Identifier"><span class="i">intStep</span></span></span>;</span>
					<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">ForLoop</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">idx</span> = <span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>]</span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">hi</span> = <span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">step</span> = <span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span> + <span class="e Int"><span class="n">2</span></span></span>]</span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">step</span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &lt; <span class="e Identifier"><span class="i">hi</span></span></span>)
						<span class="s Compound">{
							<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span> + <span class="e Int"><span class="n">3</span></span></span>]</span> = <span class="e Identifier"><span class="i">idx</span></span></span>;</span>
							<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>]</span> = <span class="e Plus"><span class="e Identifier"><span class="i">idx</span></span> + <span class="e Identifier"><span class="i">step</span></span></span></span>;</span>
							<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span>
						}</span></span>
					}</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &gt;= <span class="e Identifier"><span class="i">hi</span></span></span>)
						<span class="s Compound">{
							<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span> + <span class="e Int"><span class="n">3</span></span></span>]</span> = <span class="e Identifier"><span class="i">idx</span></span></span>;</span>
							<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>]</span> = <span class="e Plus"><span class="e Identifier"><span class="i">idx</span></span> + <span class="e Identifier"><span class="i">step</span></span></span></span>;</span>
							<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span>
						}</span></span>
					}</span></span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Foreach</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">rd</span> = <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">src</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">rd</span></span></span>]</span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Thread</span></span></span></span></span>)
					<span class="s Compound">{
						<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">MDClass</span></span><span class="t Pointer">*</span> <span class="i">proto</span>;</span></span>
						<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">method</span> = <span class="e Call"><span class="e Identifier"><span class="i">getMM</span></span>(<span class="i">t</span>, <span class="i">src</span>, <span class="i">MM</span>.<span class="i">Apply</span>, <span class="i">proto</span>)</span>;</span></span>

						<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">method</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
						<span class="s Compound">{
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">src</span>)</span>;</span>
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"No implementation of {} for type '{}'"</span>, <span class="i">MetaNames</span>[<span class="i">MM</span>.<span class="i">Apply</span>], <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
						}</span></span>

						<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">rd</span></span></span> + <span class="e Int"><span class="n">2</span></span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">rd</span></span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">rd</span></span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">src</span></span></span></span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">rd</span></span></span>]</span> = <span class="e Identifier"><span class="i">method</span></span></span>;</span>

						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">rd</span></span></span> + <span class="e Int"><span class="n">3</span></span></span></span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">commonCall</span></span>(<span class="i">t</span>, <span class="i">stackBase</span> + <span class="i">rd</span>, <span class="n">3</span>, <span class="i">callPrologue</span>(<span class="i">t</span>, <span class="i">stackBase</span> + <span class="i">rd</span>, <span class="n">3</span>, <span class="n">3</span>, <span class="i">proto</span>))</span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span></span>;</span>

						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">src</span></span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">rd</span></span></span>]</span></span>;</span>

						<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Thread</span></span></span></span></span>)
						<span class="s Compound">{
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">src</span>)</span>;</span>
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Invalid iterable type '{}' returned from opApply"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
						}</span></span>
					}</span></span>
					
					<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Thread</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mThread</span></span></span>.<span class="e Identifier"><span class="i">state</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Initial</span></span></span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to iterate over a thread that is not in the 'initial' state"</span>)</span>;</span></span>

					<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">ForeachLoop</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">jump</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>;</span></span>
					<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>++</span>;</span>
					<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">opcode</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Je</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span> == <span class="e Int"><span class="n">1</span></span></span></span>, <span class="e String"><span class="sl">"invalid 'foreachloop' jump"</span></span>)</span>;</span>

					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">rd</span> = <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">funcReg</span> = <span class="e Plus"><span class="e Identifier"><span class="i">rd</span></span> + <span class="e Int"><span class="n">3</span></span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">src</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">rd</span></span></span>]</span>;</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">funcReg</span></span></span> + <span class="e Int"><span class="n">2</span></span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">rd</span></span></span> + <span class="e Int"><span class="n">2</span></span></span>]</span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">funcReg</span></span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">rd</span></span></span> + <span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">funcReg</span></span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">rd</span></span></span>]</span></span>;</span>

					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">funcReg</span></span></span> + <span class="e Int"><span class="n">3</span></span></span></span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">rawCall</span></span>(<span class="i">t</span>, <span class="i">funcReg</span>, <span class="i">i</span>.<span class="i">imm</span>)</span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span></span>)
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">funcReg</span></span></span>]</span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>)
						<span class="s Compound">{
							<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">rd</span></span></span> + <span class="e Int"><span class="n">2</span></span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Identifier"><span class="i">funcReg</span></span></span>]</span></span>;</span>
							<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span>
						}</span></span>
					}</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">src</span></span>.<span class="e Identifier"><span class="i">mThread</span></span></span>.<span class="e Identifier"><span class="i">state</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDThread</span></span>.<span class="e Identifier"><span class="i">State</span></span></span>.<span class="e Identifier"><span class="i">Dead</span></span></span></span>)
							<span class="s Expression"><span class="e PlusAssign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">jump</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span>;</span></span>
					}</span></span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="lc">// Exception Handling</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">PushCatch</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tr</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushTR</span></span>(<span class="i">t</span>)</span>;</span></span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">isCatch</span></span></span> = <span class="e Bool"><span class="k">true</span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">catchVarSlot</span></span></span> = <span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">RelStack</span></span>)<span class="e Identifier"><span class="i">i</span></span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> = <span class="e Plus"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">actRecord</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span></span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">PushFinally</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tr</span> = <span class="e Call"><span class="e Identifier"><span class="i">pushTR</span></span>(<span class="i">t</span>)</span>;</span></span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">isCatch</span></span></span> = <span class="e Bool"><span class="k">false</span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> = <span class="e Plus"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">actRecord</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span></span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">PopCatch</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">popTR</span></span>(<span class="i">t</span>)</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">PopFinally</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">currentException</span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">popTR</span></span>(<span class="i">t</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">EndFinal</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">currentException</span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
						<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">currentException</span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">isReturning</span></span>)
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">trIndex</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Compound">{
							<span class="s While"><span class="k">while</span>(<span class="e Identity"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentTR</span></span></span>.<span class="e Identifier"><span class="i">actRecord</span></span></span> <span class="k">is</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span></span>)
							<span class="s Compound">{
								<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tr</span> = <span class="e Dot"><span class="e Deref">*<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">currentTR</span></span></span>;</span></span>
								<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">popTR</span></span>(<span class="i">t</span>)</span>;</span>

								<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Not">!<span class="e Identifier"><span class="i">tr</span></span></span>.<span class="e Identifier"><span class="i">isCatch</span></span></span>)
								<span class="s Compound">{
									<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">pc</span></span></span></span>;</span>
									<span class="s Goto"><span class="k">goto</span> <span class="i">_exceptionRetry</span>;</span>
								}</span></span>
							}</span></span>
						}</span></span>

						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">close</span></span>(<span class="i">t</span>, <span class="i">stackBase</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">true</span>)</span>;</span>

						<span class="s Expression"><span class="e PostDecr"><span class="e Identifier"><span class="i">depth</span></span>--</span>;</span>

						<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">depth</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
							<span class="s Return"><span class="k">return</span>;</span></span>

						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">isReturning</span></span> = <span class="e Bool"><span class="k">false</span></span></span>;</span>
						<span class="s Goto"><span class="k">goto</span> <span class="i">_reentry</span>;</span>
					}</span></span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Throw</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span>

				<span class="lc">// Function Calling</span>
			<span class="s Scope"><span class="s Compound">{
				<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isScript</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
				<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">word</span></span> <span class="i">numResults</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Method</span></span></span>, <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">MethodNC</span></span></span>, <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">SuperMethod</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">call</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>;</span></span>
					<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>++</span>;</span>

					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RT</span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rt</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RT</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to get a method with a non-string name (type '{}' instead)"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span></span>

					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">methodName</span> = <span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">mString</span></span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">self</span> = <span class="e Call"><span class="e Identifier"><span class="i">get</span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">opcode</span></span></span> != <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">SuperMethod</span></span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RS</span></span> = <span class="e Deref">*<span class="e Identifier"><span class="i">self</span></span></span></span>;</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">proto</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to perform a supercall in a function where there is no super class"</span>)</span>;</span></span>

						<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">self</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span> &amp;&amp; <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">self</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span></span></span>)
						<span class="s Compound">{
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">self</span>)</span>;</span>
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to perform a supercall in a function where 'this' is a '{}', not an 'instance' or 'class'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
						}</span></span>

						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RS</span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">proto</span></span></span></span>;</span>
					}</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numResults</span></span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">call</span></span>.<span class="e Identifier"><span class="i">rt</span></span></span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span>
					<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numParams</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">call</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numParams</span></span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Paren">(<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span></span>;</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numParams</span></span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">call</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">call</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span></span></span>;</span>
					}</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">isScript</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">commonMethodCall</span></span>(<span class="i">t</span>, <span class="i">stackBase</span> + <span class="i">i</span>.<span class="i">rd</span>, <span class="i">self</span>, &amp;<span class="i">RS</span>, <span class="i">methodName</span>, <span class="i">numResults</span>, <span class="i">numParams</span>, <span class="i">i</span>.<span class="i">opcode</span> == <span class="i">Op</span>.<span class="i">MethodNC</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">call</span></span>.<span class="e Identifier"><span class="i">opcode</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Call</span></span></span></span>)
						<span class="s Goto"><span class="k">goto</span> <span class="i">_commonCall</span>;</span>
					<span class="k">else</span>
						<span class="s Goto"><span class="k">goto</span> <span class="i">_commonTailcall</span>;</span></span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Call</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numResults</span></span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rt</span></span></span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span>
					<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numParams</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numParams</span></span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Paren">(<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span></span>;</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numParams</span></span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span></span></span>;</span>
					}</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">isScript</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">callPrologue</span></span>(<span class="i">t</span>, <span class="i">stackBase</span> + <span class="i">i</span>.<span class="i">rd</span>, <span class="i">numResults</span>, <span class="i">numParams</span>, <span class="k">null</span>)</span></span>;</span>

					<span class="lc">// fall through</span>
				<span class="s Labeled"><span class="i">_commonCall</span>:
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">isScript</span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">depth</span></span>++</span>;</span>
						<span class="s Goto"><span class="k">goto</span> <span class="i">_reentry</span>;</span>
					}</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numResults</span></span> &gt;= <span class="e Int"><span class="n">0</span></span></span>)
							<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span></span>;</span></span>
					}</span></span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Tailcall</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numResults</span></span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rt</span></span></span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span>
					<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numParams</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numParams</span></span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> - <span class="e Paren">(<span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span> + <span class="e Int"><span class="n">1</span></span></span>)</span></span></span>;</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numParams</span></span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span></span></span>;</span>
					}</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">isScript</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">callPrologue</span></span>(<span class="i">t</span>, <span class="i">stackBase</span> + <span class="i">i</span>.<span class="i">rd</span>, <span class="i">numResults</span>, <span class="i">numParams</span>, <span class="k">null</span>)</span></span>;</span>

					<span class="lc">// fall through</span>
				<span class="s Labeled"><span class="i">_commonTailcall</span>:
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Identifier"><span class="i">isScript</span></span>)
					<span class="s Compound">{
						<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">prevAR</span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span> - <span class="e Int"><span class="n">1</span></span></span>;</span></span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">close</span></span>(<span class="i">t</span>, <span class="i">prevAR</span>.<span class="i">base</span>)</span>;</span>

						<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">diff</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">ptrdiff_t</span></span>)<span class="e Paren">(<span class="e Minus"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">returnSlot</span></span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">prevAR</span></span>.<span class="e Identifier"><span class="i">returnSlot</span></span></span></span>)</span></span>;</span></span>

						<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tc</span> = <span class="e Plus"><span class="e Dot"><span class="e Identifier"><span class="i">prevAR</span></span>.<span class="e Identifier"><span class="i">numTailcalls</span></span></span> + <span class="e Int"><span class="n">1</span></span></span>;</span></span>
						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">numReturns</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">prevAR</span></span>.<span class="e Identifier"><span class="i">numReturns</span></span></span></span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Deref">*<span class="e Identifier"><span class="i">prevAR</span></span></span> = <span class="e Dot"><span class="e Deref">*<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span></span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">prevAR</span></span>.<span class="e Identifier"><span class="i">numTailcalls</span></span></span> = <span class="e Identifier"><span class="i">tc</span></span></span>;</span>
						<span class="s Expression"><span class="e MinusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">prevAR</span></span>.<span class="e Identifier"><span class="i">base</span></span></span> -= <span class="e Identifier"><span class="i">diff</span></span></span>;</span>
						<span class="s Expression"><span class="e MinusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">prevAR</span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span> -= <span class="e Identifier"><span class="i">diff</span></span></span>;</span>
						<span class="s Expression"><span class="e MinusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">prevAR</span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span> -= <span class="e Identifier"><span class="i">diff</span></span></span>;</span>
						<span class="s Expression"><span class="e MinusAssign"><span class="e Dot"><span class="e Identifier"><span class="i">prevAR</span></span>.<span class="e Identifier"><span class="i">returnSlot</span></span></span> -= <span class="e Identifier"><span class="i">diff</span></span></span>;</span>

						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">popAR</span></span>(<span class="i">t</span>)</span>;</span>

						<span class="lc">//memmove(&amp;t.stack[prevAR.returnSlot], &amp;t.stack[prevAR.returnSlot + diff], (prevAR.savedTop - prevAR.returnSlot) * MDValue.sizeof);</span>

						<span class="s For"><span class="k">for</span>(<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">idx</span> = <span class="e Dot"><span class="e Identifier"><span class="i">prevAR</span></span>.<span class="e Identifier"><span class="i">returnSlot</span></span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">idx</span></span> &lt; <span class="e Dot"><span class="e Identifier"><span class="i">prevAR</span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span></span>; <span class="e PostIncr"><span class="e Identifier"><span class="i">idx</span></span>++</span>)
							<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">idx</span></span>]</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">idx</span></span> + <span class="e Identifier"><span class="i">diff</span></span></span>]</span></span>;</span></span>

						<span class="s Goto"><span class="k">goto</span> <span class="i">_reentry</span>;</span>
					}</span></span>

					<span class="lc">// Do nothing for native calls.  The following return instruction will catch it.</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>
			}</span></span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Ret</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">firstResult</span> = <span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">imm</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">saveResults</span></span>(<span class="i">t</span>, <span class="i">t</span>, <span class="i">firstResult</span>, <span class="i">t</span>.<span class="i">stackIndex</span> - <span class="i">firstResult</span>)</span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span></span>;</span>
					}</span>
					<span class="k">else</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">saveResults</span></span>(<span class="i">t</span>, <span class="i">t</span>, <span class="i">firstResult</span>, <span class="i">i</span>.<span class="i">imm</span> - <span class="n">1</span>)</span>;</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">isReturning</span></span> = <span class="e Bool"><span class="k">true</span></span></span>;</span>

					<span class="s While"><span class="k">while</span>(<span class="e AndAnd"><span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">trIndex</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span> &amp;&amp; <span class="e Identity"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentTR</span></span></span>.<span class="e Identifier"><span class="i">actRecord</span></span></span> <span class="k">is</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span></span></span>)
					<span class="s Compound">{
						<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tr</span> = <span class="e Dot"><span class="e Deref">*<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">currentTR</span></span></span>;</span></span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">popTR</span></span>(<span class="i">t</span>)</span>;</span>

						<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Not">!<span class="e Identifier"><span class="i">tr</span></span></span>.<span class="e Identifier"><span class="i">isCatch</span></span></span>)
						<span class="s Compound">{
							<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">pc</span></span></span></span>;</span>
							<span class="s Goto"><span class="k">goto</span> <span class="i">_exceptionRetry</span>;</span>
						}</span></span>
					}</span></span>

					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">close</span></span>(<span class="i">t</span>, <span class="i">stackBase</span>)</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">true</span>)</span>;</span>

					<span class="s Expression"><span class="e PostDecr"><span class="e Identifier"><span class="i">depth</span></span>--</span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">depth</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Return"><span class="k">return</span>;</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">isReturning</span></span> = <span class="e Bool"><span class="k">false</span></span></span>;</span>
					<span class="s Goto"><span class="k">goto</span> <span class="i">_reentry</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Vararg</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">numVarargs</span> = <span class="e Minus"><span class="e Identifier"><span class="i">stackBase</span></span> - <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">dest</span> = <span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>;</span></span>

					<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numNeeded</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">uimm</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numNeeded</span></span> = <span class="e Identifier"><span class="i">numVarargs</span></span></span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">dest</span></span> + <span class="e Identifier"><span class="i">numVarargs</span></span></span></span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkStack</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">stackIndex</span>)</span>;</span>
					}</span>
					<span class="k">else</span>
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numNeeded</span></span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">uimm</span></span></span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span></span>

					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">src</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span>;</span></span>
					
					<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numNeeded</span></span> &lt;= <span class="e Identifier"><span class="i">numVarargs</span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">dest</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">dest</span></span> + <span class="e Identifier"><span class="i">numNeeded</span></span></span>]</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">src</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">src</span></span> + <span class="e Identifier"><span class="i">numNeeded</span></span></span>]</span></span>;</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">dest</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">dest</span></span> + <span class="e Identifier"><span class="i">numVarargs</span></span></span>]</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">src</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">src</span></span> + <span class="e Identifier"><span class="i">numVarargs</span></span></span>]</span></span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">dest</span></span> + <span class="e Identifier"><span class="i">numVarargs</span></span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">dest</span></span> + <span class="e Identifier"><span class="i">numNeeded</span></span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span>
					}</span></span>

					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">VargLen</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">mdint</span></span>)<span class="e Paren">(<span class="e Minus"><span class="e Identifier"><span class="i">stackBase</span></span> - <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span></span>)</span></span></span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">VargIndex</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">numVarargs</span> = <span class="e Minus"><span class="e Identifier"><span class="i">stackBase</span></span> - <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span></span>;</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RS</span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RS</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to index 'vararg' with a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span></span>

					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">index</span> = <span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">index</span></span> += <span class="e Identifier"><span class="i">numVarargs</span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &gt;= <span class="e Identifier"><span class="i">numVarargs</span></span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Invalid 'vararg' index: {} (only have {})"</span>, <span class="i">index</span>, <span class="i">numVarargs</span>)</span>;</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span> + <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">index</span></span></span></span>]</span></span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">VargIndexAssign</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">numVarargs</span> = <span class="e Minus"><span class="e Identifier"><span class="i">stackBase</span></span> - <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span></span>;</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RS</span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Int</span></span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RS</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to index 'vararg' with a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span></span>

					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">index</span> = <span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mInt</span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">index</span></span> += <span class="e Identifier"><span class="i">numVarargs</span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &gt;= <span class="e Identifier"><span class="i">numVarargs</span></span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Invalid 'vararg' index: {} (only have {})"</span>, <span class="i">index</span>, <span class="i">numVarargs</span>)</span>;</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span> + <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">index</span></span></span></span>]</span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rt</span>)</span></span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">VargSlice</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">numVarargs</span> = <span class="e Minus"><span class="e Identifier"><span class="i">stackBase</span></span> - <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">vargBase</span></span></span></span>;</span></span>
					
					<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">lo</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>
					<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">mdint</span></span> <span class="i">hi</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">correctIndices</span></span></span>(<span class="i">lo</span>, <span class="i">hi</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span> + <span class="n">1</span>), <span class="i">numVarargs</span>)</span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RS</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RT</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to slice 'vararg' with '{}' and '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e OrOr"><span class="e OrOr"><span class="e OrOr"><span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">lo</span></span> &gt; <span class="e Identifier"><span class="i">hi</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">lo</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">lo</span></span> &gt; <span class="e Identifier"><span class="i">numVarargs</span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">hi</span></span> &lt; <span class="e Int"><span class="n">0</span></span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">hi</span></span> &gt; <span class="e Identifier"><span class="i">numVarargs</span></span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Invalid vararg slice indices [{} .. {}]"</span>, <span class="i">lo</span>, <span class="i">hi</span>)</span>;</span></span>

					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">sliceSize</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Paren">(<span class="e Minus"><span class="e Identifier"><span class="i">hi</span></span> - <span class="e Identifier"><span class="i">lo</span></span></span>)</span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">src</span> = <span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">lo</span></span></span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">dest</span> = <span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">uword</span></span>)<span class="e Identifier"><span class="i">i</span></span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>;</span></span>

					<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">numNeeded</span> = <span class="e VoidInit"><span class="k">void</span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">uimm</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numNeeded</span></span> = <span class="e Identifier"><span class="i">sliceSize</span></span></span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">dest</span></span> + <span class="e Identifier"><span class="i">sliceSize</span></span></span></span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">checkStack</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">stackIndex</span>)</span>;</span>
					}</span>
					<span class="k">else</span>
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">numNeeded</span></span> = <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">uimm</span></span></span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Identifier"><span class="i">numNeeded</span></span> &lt;= <span class="e Identifier"><span class="i">sliceSize</span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">dest</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">dest</span></span> + <span class="e Identifier"><span class="i">numNeeded</span></span></span>]</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">src</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">src</span></span> + <span class="e Identifier"><span class="i">numNeeded</span></span></span>]</span></span>;</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">dest</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">dest</span></span> + <span class="e Identifier"><span class="i">sliceSize</span></span></span>]</span> = <span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">src</span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">src</span></span> + <span class="e Identifier"><span class="i">sliceSize</span></span></span>]</span></span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">dest</span></span> + <span class="e Identifier"><span class="i">sliceSize</span></span></span> .. <span class="e Plus"><span class="e Identifier"><span class="i">dest</span></span> + <span class="e Identifier"><span class="i">numNeeded</span></span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span>
					}</span></span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Yield</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Identifier"><span class="i">t</span></span> <span class="k">is</span> <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">mainThread</span></span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to yield out of the main thread"</span>)</span>;</span></span>

					<span class="s Version"><span class="k">version</span>(<span class="i">MDRestrictedCoro</span>)
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to yield across native / metamethod call boundary"</span>)</span>;</span></span>

						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">savedCallDepth</span></span></span> = <span class="e Identifier"><span class="i">depth</span></span></span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">yieldImpl</span></span>(<span class="i">t</span>, <span class="i">stackBase</span> + <span class="i">i</span>.<span class="i">rd</span>, <span class="i">i</span>.<span class="i">rt</span> - <span class="n">1</span>, <span class="i">i</span>.<span class="i">rs</span> - <span class="n">1</span>)</span>;</span>
						<span class="s Return"><span class="k">return</span>;</span>
					}</span>
					<span class="k">else</span> <span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">yieldImpl</span></span>(<span class="i">t</span>, <span class="i">stackBase</span> + <span class="i">i</span>.<span class="i">rd</span>, <span class="i">i</span>.<span class="i">rt</span> - <span class="n">1</span>, <span class="i">i</span>.<span class="i">rs</span> - <span class="n">1</span>)</span>;</span>
					}</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span> &amp;&amp; <span class="e Dot"><span class="e Dot"><span class="e Not">!<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">coroFunc</span></span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span></span>)
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to yield from script coroutine across native / metamethod call boundary"</span>)</span>;</span></span>

						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">savedCallDepth</span></span></span> = <span class="e Identifier"><span class="i">depth</span></span></span>;</span>
						<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Identifier"><span class="i">yieldImpl</span></span>(<span class="i">t</span>, <span class="i">stackBase</span> + <span class="i">i</span>.<span class="i">rd</span>, <span class="i">i</span>.<span class="i">rt</span> - <span class="n">1</span>, <span class="i">i</span>.<span class="i">rs</span> - <span class="n">1</span>)</span>)
							<span class="s Return"><span class="k">return</span>;</span></span>
					}</span></span></span>

					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">CheckParams</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">val</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">stackBase</span></span>]</span>;</span></span>

					<span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="i">idx</span></span>, <span class="o Parameter"><span class="i">mask</span></span></span>; <span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">scriptFunc</span></span></span>.<span class="e Identifier"><span class="i">paramMasks</span></span></span>)
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e Not">!<span class="e Paren">(<span class="e And"><span class="e Identifier"><span class="i">mask</span></span> &amp; <span class="e Paren">(<span class="e LShift"><span class="e Int"><span class="n">1</span></span> &lt;&lt; <span class="e Dot"><span class="e Identifier"><span class="i">val</span></span>.<span class="e Identifier"><span class="i">type</span></span></span></span>)</span></span>)</span></span>)
						<span class="s Compound">{
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, <span class="i">val</span>)</span>;</span>

							<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Identifier"><span class="i">idx</span></span> == <span class="e Int"><span class="n">0</span></span></span>)
								<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"'this' parameter: type '{}' is not allowed"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
							<span class="k">else</span>
								<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Parameter {}: type '{}' is not allowed"</span>, <span class="i">idx</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span></span>
						}</span></span>

						<span class="s Expression"><span class="e PostIncr"><span class="e Identifier"><span class="i">val</span></span>++</span>;</span>
					}</span></span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">CheckObjParam</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RS</span></span> = <span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span></span>]</span></span>;</span>
					
					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Instance</span></span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Bool"><span class="k">true</span></span></span>;</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RT</span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rt</span>)</span></span>;</span>

						<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span></span>)
						<span class="s Compound">{
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RT</span>)</span>;</span>
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Parameter {}: instance type constraint type must be 'class', not '{}'"</span>, <span class="i">i</span>.<span class="i">rs</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
						}</span></span>

						<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">instance</span></span>.<span class="e Identifier"><span class="i">derivesFrom</span></span></span>(<span class="i">RS</span>.<span class="i">mInstance</span>, <span class="i">RT</span>.<span class="i">mClass</span>)</span></span>;</span>
					}</span></span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">ObjParamFail</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">t</span>.<span class="i">stack</span>[<span class="i">stackBase</span> + <span class="i">i</span>.<span class="i">rs</span>])</span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"'this' parameter: type '{}' is not allowed"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					<span class="k">else</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Parameter {}: type '{}' is not allowed"</span>, <span class="i">i</span>.<span class="i">rs</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span></span>
						
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="lc">// Array and List Operations</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Length</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">lenImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">LengthAssign</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">lenaImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Append</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">append</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">t</span>.<span class="i">stack</span>[<span class="i">stackBase</span> + <span class="i">i</span>.<span class="i">rd</span>].<span class="i">mArray</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">SetArray</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">sliceBegin</span> = <span class="e Plus"><span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span> + <span class="e Int"><span class="n">1</span></span></span>;</span></span>
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">a</span> = <span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>]</span>.<span class="e Identifier"><span class="i">mArray</span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">setBlock</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">a</span>, <span class="i">i</span>.<span class="i">rt</span>, <span class="i">t</span>.<span class="i">stack</span>[<span class="i">sliceBegin</span> .. <span class="i">t</span>.<span class="i">stackIndex</span>])</span>;</span>
						<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">savedTop</span></span></span></span>;</span>
					}</span>
					<span class="k">else</span>
						<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">setBlock</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">a</span>, <span class="i">i</span>.<span class="i">rt</span>, <span class="i">t</span>.<span class="i">stack</span>[<span class="i">sliceBegin</span> .. <span class="i">sliceBegin</span> + <span class="i">i</span>.<span class="i">rs</span> - <span class="n">1</span>])</span>;</span></span>

					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Cat</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">catImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">stackBase</span> + <span class="i">i</span>.<span class="i">rs</span>, <span class="i">i</span>.<span class="i">rt</span>)</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">CatEq</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">catEqImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">stackBase</span> + <span class="i">i</span>.<span class="i">rs</span>, <span class="i">i</span>.<span class="i">rt</span>)</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Index</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">idxImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>), <span class="k">false</span>)</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">IndexAssign</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">idxaImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>), <span class="k">false</span>)</span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Field</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RT</span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rt</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RT</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Field name must be a string, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span></span>

					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">fieldImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">RT</span>.<span class="i">mString</span>, <span class="k">false</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">FieldAssign</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RS</span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">String</span></span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RS</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Field name must be a string, not a '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span></span>

					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">fieldaImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">RS</span>.<span class="i">mString</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>), <span class="k">false</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Slice</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">base</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span></span>]</span>;</span></span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">sliceImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rd</span>), <span class="i">base</span>, <span class="i">base</span> + <span class="n">1</span>, <span class="i">base</span> + <span class="n">2</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">SliceAssign</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">base</span> = <span class="e Index"><span class="e Dot"><span class="e Address">&amp;<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>]</span>;</span></span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">sliceaImpl</span></span>(<span class="i">t</span>, <span class="i">base</span>, <span class="i">base</span> + <span class="n">1</span>, <span class="i">base</span> + <span class="n">2</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">NotIn</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">val</span> = <span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">inImpl</span></span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span></span>
					<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Identifier"><span class="i">val</span></span></span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">In</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">val</span> = <span class="e Call"><span class="e Identifier"><span class="i">inImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>), <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>;</span></span>
					<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Identifier"><span class="i">val</span></span></span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="lc">// Value Creation</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">NewArray</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>]</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">i</span>.<span class="i">uimm</span>)</span></span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">NewTable</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rd</span></span></span></span>]</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">table</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>)</span></span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Closure</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">newDef</span> = <span class="e Index"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">scriptFunc</span></span></span>.<span class="e Identifier"><span class="i">innerFuncs</span></span></span>[<span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span>]</span>;</span></span>

					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">funcEnv</span> = <span class="e Identifier"><span class="i">env</span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rt</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">funcEnv</span></span> = <span class="e Dot"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">stackBase</span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rt</span></span></span></span>]</span>.<span class="e Identifier"><span class="i">mNamespace</span></span></span></span>;</span></span>

					<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">newDef</span></span>.<span class="e Identifier"><span class="i">isPure</span></span></span>)
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e Identity"><span class="e Dot"><span class="e Identifier"><span class="i">newDef</span></span>.<span class="e Identifier"><span class="i">cachedFunc</span></span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
							<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">newDef</span></span>.<span class="e Identifier"><span class="i">cachedFunc</span></span></span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">func</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">funcEnv</span>, <span class="i">newDef</span>)</span></span>;</span></span>

						<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Dot"><span class="e Identifier"><span class="i">newDef</span></span>.<span class="e Identifier"><span class="i">cachedFunc</span></span></span></span>;</span>
					}</span>
					<span class="k">else</span>
					<span class="s Compound">{
						<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">n</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">func</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">funcEnv</span>, <span class="i">newDef</span>)</span>;</span></span>
						<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">upvals</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">n</span></span>.<span class="e Identifier"><span class="i">scriptUpvals</span></span></span>()</span>;</span></span>
						<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">currentUpvals</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span>.<span class="e Identifier"><span class="i">scriptUpvals</span></span></span>()</span>;</span></span>

						<span class="s For"><span class="k">for</span>(<span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">uword</span></span> <span class="i">index</span> = <span class="e Int"><span class="n">0</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">index</span></span> &lt; <span class="e Dot"><span class="e Identifier"><span class="i">newDef</span></span>.<span class="e Identifier"><span class="i">numUpvals</span></span></span></span>; <span class="e PostIncr"><span class="e Identifier"><span class="i">index</span></span>++</span>)
						<span class="s Compound">{
							<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>.<span class="e Identifier"><span class="i">opcode</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Move</span></span></span></span>, <span class="e String"><span class="sl">"invalid closure upvalue op"</span></span>)</span>;</span>

							<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>.<span class="e Identifier"><span class="i">rd</span></span></span> == <span class="e Int"><span class="n">0</span></span></span>)
								<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">upvals</span></span>[<span class="e Identifier"><span class="i">index</span></span>]</span> = <span class="e Call"><span class="e Identifier"><span class="i">findUpvalue</span></span>(<span class="i">t</span>, <span class="i">t</span>.<span class="i">currentAR</span>.<span class="i">pc</span>.<span class="i">rs</span>)</span></span>;</span>
							<span class="k">else</span>
							<span class="s Compound">{
								<span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>.<span class="e Identifier"><span class="i">rd</span></span></span> == <span class="e Int"><span class="n">1</span></span></span>, <span class="e String"><span class="sl">"invalid closure upvalue rd"</span></span>)</span>;</span>
								<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">upvals</span></span>[<span class="e Identifier"><span class="i">index</span></span>]</span> = <span class="e Index"><span class="e Identifier"><span class="i">currentUpvals</span></span>[<span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>.<span class="e Identifier"><span class="i">uimm</span></span></span>]</span></span>;</span>
							}</span></span>

							<span class="s Expression"><span class="e PostIncr"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span>++</span>;</span>
						}</span></span>

						<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Identifier"><span class="i">n</span></span></span>;</span>
					}</span></span>

					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">SetEnv</span></span></span>: <span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">get</span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span>.<span class="e Identifier"><span class="i">mFunction</span></span></span>.<span class="e Identifier"><span class="i">environment</span></span></span> = <span class="e Dot"><span class="e Call"><span class="e Identifier"><span class="i">get</span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span>.<span class="e Identifier"><span class="i">mNamespace</span></span></span></span>;</span> <span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Class</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RS</span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RT</span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rt</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Class</span></span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RT</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempting to derive a class from a value of type '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span>
					<span class="k">else</span>
						<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">classobj</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">RS</span>.<span class="i">mString</span>, <span class="i">RT</span>.<span class="i">mClass</span>)</span></span>;</span></span>

					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Coroutine</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RS</span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Function</span></span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RS</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Coroutines must be created with a function, not '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span></span>
					
					<span class="s Version"><span class="k">version</span>(<span class="i">MDRestrictedCoro</span>)
					<span class="s Compound">{
						<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">RS</span></span>.<span class="e Identifier"><span class="i">mFunction</span></span></span>.<span class="e Identifier"><span class="i">isNative</span></span></span>)
							<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Native functions may not be used as the body of a coroutine"</span>)</span>;</span></span>
					}</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">thread</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>, <span class="i">RS</span>.<span class="i">mFunction</span>)</span></span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">name</span> = <span class="e Dot"><span class="e Index"><span class="e Identifier"><span class="i">constTable</span></span>[<span class="e Dot"><span class="e Identifier"><span class="i">i</span></span>.<span class="e Identifier"><span class="i">rs</span></span></span>]</span>.<span class="e Identifier"><span class="i">mString</span></span></span>;</span></span>
					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RT</span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rt</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> == <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Null</span></span></span></span>)
						<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">name</span>)</span></span>;</span>
					<span class="k">else</span> <span class="s If"><span class="k">if</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">RT</span></span>.<span class="e Identifier"><span class="i">type</span></span></span> != <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">Type</span></span></span>.<span class="e Identifier"><span class="i">Namespace</span></span></span></span>)
					<span class="s Compound">{
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">typeString</span></span>(<span class="i">t</span>, &amp;<span class="i">RT</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushStringObj</span></span>(<span class="i">t</span>, <span class="i">name</span>)</span>;</span>
						<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Attempted to use a '{}' as a parent namespace for namespace '{}'"</span>, <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">2</span>), <span class="i">getString</span>(<span class="i">t</span>, -<span class="n">1</span>))</span>;</span>
					}</span>
					<span class="k">else</span>
						<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">name</span>, <span class="i">RT</span>.<span class="i">mNamespace</span>)</span></span>;</span></span></span>

					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">NamespaceNP</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tmp</span> = <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">namespace</span></span>.<span class="e Identifier"><span class="i">create</span></span></span>(<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">constTable</span>[<span class="i">i</span>.<span class="i">rs</span>].<span class="i">mString</span>, <span class="i">env</span>)</span>;</span></span>
					<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Identifier"><span class="i">tmp</span></span></span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">maybeGC</span></span>(<span class="i">t</span>)</span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="lc">// Class stuff</span>
				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">As</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">RS</span></span> = <span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rs</span>)</span></span>;</span>

					<span class="s If"><span class="k">if</span>(<span class="e Call"><span class="e Identifier"><span class="i">asImpl</span></span>(<span class="i">t</span>, &amp;<span class="i">RS</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rt</span>))</span>)
						<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Identifier"><span class="i">RS</span></span></span>;</span>
					<span class="k">else</span>
						<span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span></span>

					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">SuperOf</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assign"><span class="e Call"><span class="e Deref">*<span class="e Identifier"><span class="i">get</span></span></span>(<span class="i">i</span>.<span class="i">rd</span>)</span> = <span class="e Call"><span class="e Identifier"><span class="i">superOfImpl</span></span>(<span class="i">t</span>, <span class="i">get</span>(<span class="i">i</span>.<span class="i">rs</span>))</span></span>;</span>
					<span class="s Break"><span class="k">break</span>;</span></span></span></span>

				<span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Je</span></span></span>:</span></span></span>
				<span class="s Scope"><span class="s Compound"><span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Jle</span></span></span>:</span></span></span>
				<span class="s Scope"><span class="s Compound"><span class="s Case"><span class="k">case</span> <span class="e Dot"><span class="e Identifier"><span class="i">Op</span></span>.<span class="e Identifier"><span class="i">Jlt</span></span></span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>, <span class="e String"><span class="sl">"lone conditional jump instruction"</span></span>)</span>;</span></span></span></span>

				<span class="s Default"><span class="k">default</span>:
					<span class="s Scope"><span class="s Compound"><span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">throwException</span></span>(<span class="i">t</span>, <span class="sl">"Unimplemented opcode \"{}\""</span>, <span class="i">i</span>)</span>;</span></span></span></span>
			}</span></span>
		}</span></span>
	}</span>
	<span class="k">catch</span>(<span class="o Parameter"><span class="t Identifier"><span class="i">MDException</span></span> <span class="i">e</span></span>)
	<span class="s Compound">{
		<span class="s While"><span class="k">while</span>(<span class="e Rel"><span class="e Identifier"><span class="i">depth</span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Compound">{
			<span class="s While"><span class="k">while</span>(<span class="e AndAnd"><span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">trIndex</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span> &amp;&amp; <span class="e Identity"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentTR</span></span></span>.<span class="e Identifier"><span class="i">actRecord</span></span></span> <span class="k">is</span> <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span></span></span>)
			<span class="s Compound">{
				<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">tr</span> = <span class="e Dot"><span class="e Deref">*<span class="e Identifier"><span class="i">t</span></span></span>.<span class="e Identifier"><span class="i">currentTR</span></span></span>;</span></span>
				<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">popTR</span></span>(<span class="i">t</span>)</span>;</span>

				<span class="s If"><span class="k">if</span>(<span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">isCatch</span></span></span>)
				<span class="s Compound">{
					<span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">base</span> = <span class="e Plus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackBase</span></span></span> + <span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">catchVarSlot</span></span></span></span>;</span></span>

					<span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Identifier"><span class="i">base</span></span>]</span> = <span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">exception</span></span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">exception</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">isThrowing</span></span></span> = <span class="e Bool"><span class="k">false</span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">currentException</span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>

					<span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stack</span></span></span>[<span class="e Plus"><span class="e Identifier"><span class="i">base</span></span> + <span class="e Int"><span class="n">1</span></span></span> .. <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">stackIndex</span></span></span>]</span> = <span class="e Dot"><span class="e Identifier"><span class="i">MDValue</span></span>.<span class="e Identifier"><span class="i">nullValue</span></span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">pc</span></span></span></span>;</span>
					<span class="s Goto"><span class="k">goto</span> <span class="i">_exceptionRetry</span>;</span>
				}</span>
				<span class="k">else</span>
				<span class="s Compound">{
					<span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">currentException</span></span> = <span class="e Identifier"><span class="i">e</span></span></span>;</span>
					<span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">pc</span></span></span> = <span class="e Dot"><span class="e Identifier"><span class="i">tr</span></span>.<span class="e Identifier"><span class="i">pc</span></span></span></span>;</span>
					<span class="s Goto"><span class="k">goto</span> <span class="i">_exceptionRetry</span>;</span>
				}</span></span>
			}</span></span>

			<span class="s If"><span class="k">if</span>(<span class="e AndAnd"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span> &amp;&amp; <span class="e Identity"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">func</span></span></span> !<span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span></span>)
			<span class="s Compound">{
				<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">traceback</span></span></span>.<span class="e Identifier"><span class="i">append</span></span></span>(&amp;<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">getDebugLoc</span>(<span class="i">t</span>))</span>;</span>

				<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">currentAR</span></span></span>.<span class="e Identifier"><span class="i">numTailcalls</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
				<span class="s Compound">{
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pushFormat</span></span>(<span class="i">t</span>, <span class="sl">"&lt;{} tailcalls&gt;"</span>, <span class="i">t</span>.<span class="i">currentAR</span>.<span class="i">numTailcalls</span>)</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">vm</span></span></span>.<span class="e Identifier"><span class="i">traceback</span></span></span>.<span class="e Identifier"><span class="i">append</span></span></span>(&amp;<span class="i">t</span>.<span class="i">vm</span>.<span class="i">alloc</span>, <span class="i">Location</span>(<span class="i">getStringObj</span>(<span class="i">t</span>, -<span class="n">1</span>), -<span class="n">1</span>, <span class="i">Location</span>.<span class="i">Type</span>.<span class="i">Script</span>))</span>;</span>
					<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">pop</span></span>(<span class="i">t</span>)</span>;</span>
				}</span></span>
			}</span></span>

			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">false</span>)</span>;</span>
			<span class="s Expression"><span class="e PostDecr"><span class="e Identifier"><span class="i">depth</span></span>--</span>;</span>
		}</span></span>

		<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span>
	}</span></span>
	<span class="s Catch"><span class="k">catch</span>(<span class="o Parameter"><span class="t Identifier"><span class="i">MDHaltException</span></span> <span class="i">e</span></span>)
	<span class="s Compound">{
		<span class="s While"><span class="k">while</span>(<span class="e Rel"><span class="e Identifier"><span class="i">depth</span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
		<span class="s Compound">{
			<span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">callEpilogue</span></span>(<span class="i">t</span>, <span class="k">false</span>)</span>;</span>
			<span class="s Expression"><span class="e PostDecr"><span class="e Identifier"><span class="i">depth</span></span>--</span>;</span>
		}</span></span>

		<span class="lc">// TODO: investigate?</span>
		<span class="s Version"><span class="k">version</span>(<span class="i">MDExtendedCoro</span>)
		<span class="s Compound">{
			<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">arIndex</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
				<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span></span>
		}</span>
		<span class="k">else</span>
		<span class="s Compound">{
			<span class="s If"><span class="k">if</span>(<span class="e Rel"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">nativeCallDepth</span></span></span> &gt; <span class="e Int"><span class="n">0</span></span></span>)
				<span class="s Throw"><span class="k">throw</span> <span class="e Identifier"><span class="i">e</span></span>;</span></span>
		}</span></span>

		<span class="s Return"><span class="k">return</span>;</span>
	}</span></span></span>
}</span></span></span></span></span></span></span></span></span></span>
</pre></td>
</tr></table>
</body>
</html>